# Hunt Ad Acl

> ACL-abuse expert of the AD split: BloodHound collection, edge

- Skill: `encod3d-sec/hunt-ad-acl` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx get-skill add encod3d-sec/hunt-ad-acl`
- Raw SKILL.md: https://api.skillmd.com/api/skills/encod3d-sec/hunt-ad-acl/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: Encod3d-Sec (https://skillmd.com/u/encod3d-sec)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/encod3d-sec/hunt-ad-acl

---


# Hunt: AD - ACL expert (microskill)

ACL-abuse expert of the AD split: BloodHound collection, edge
exercise (GenericAll/GenericWrite/WriteDACL/ForceChangePassword/
AddMember/AddAllowedToAct), GPO and ADIDNS abuse, and the
terminal-user re-enum discipline that beats the BloodHound blind
spot. The mapper (hunt-ad) owns enum waves and dispatch.

Wiki mass: active-directory-access-controls-aclace (17.6KB), GPO,
ADIDNS, groups pages.

2025-26 technique ladder: `references/bypass-arsenal.md` (NEW classes, defense->bypass map).

## Wiki

Hub: [[active-directory-moc]] - Primary page:
[[active-directory-access-controls-aclace]]
Anchors: [[active-directory-group-policy-objects]],
[[active-directory-integrated-dns-adidns]], [[active-directory-groups]],
[[bloodhound]]
**REFS:** [[active-directory-access-controls-aclace]], [[bloodhound]]

qmd on hint only: "BloodHound ACL GenericWrite WriteDACL
ForceChangePassword GPO ADIDNS" - the aclace page first.

## Paths (binding - shared with the mapper run)

    # seat side (wsl):
    ENG_DIR=/mnt/c/Users/Lenovo/Desktop/VMshare/<eng>/<eng>
    RUN=$ENG_DIR/hunt/ad/<domain>          # SHARED with hunt-ad
    # VM side:
    ENG_DIR=/mnt/VMshare/<eng>/<eng>
    RUN=$ENG_DIR/hunt/ad/<domain>

Experts write probes/ad-acl*.jsonl into the mapper's $RUN tree. The
BloodHound zip archives under probes/raw/ (leak hygiene).

## Transport

Every VM-native command block ships through ONE documented transport:

    cd /mnt/c/Users/Lenovo/Documents/ObisidianVaults/ZTorch/ZTorch && bash scripts/vm-ssh.sh '<command>'

- vm-ssh lands as user tz (NOT root); one argument per call; quotes
  ship as base64 (`echo <b64> | base64 -d | bash`).
- Collection through a SOCKS pivot needs --dns-server <dc> --dns-tcp
  (UDP DNS never traverses the tunnel - "Could not find a domain
  controller" is this, not a dead DC); LDAP ops through pivots use
  -ldap-scheme ldap. [[pivoting-tunneling]] carries toolkit gotchas.
- HTTP fetches via /opt/scope-shim/bin/{curl,httpx}; out-of-scope
  dies rc 126; UNKNOWN = ADVISORY, self-deny.
- Long collections run detached (vm-bg.sh) + logs read back.

## Entry gate

All four must pass; each is falsifiable:

1. Active engagement exists; domain/DC on targets/<eng>/scope.md.
   Scope-guard is the deny.
2. hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
3. Mapper verified: $RUN/raw/domain-map.md exists AND >= 1
   owned/known principal (loot.md or users.md row) AND the
   AD-HUNT-DONE pointer ($ENG_DIR/hunt-ad-<domain>.md) names acl in
   next=. Missing = dispatch hunt-ad first.
4. Toolchain preflight (fails LOUD):

       for t in /usr/bin/jq /usr/bin/python3; do
         [ -x "$t" ] || { echo "MISSING TOOL: $t"; exit 1; }
       done
       command -v nxc >/dev/null          || { pip3 install --user --break-system-packages -q pipx               && /home/tz/.local/bin/pipx install netexec; }          || echo "N/A: nxc absent on VM (install failed)"
       python3 -c "import bloodhound" 2>/dev/null \
         || pip3 install --user --break-system-packages -q bloodhound \
         || echo "N/A: bloodhound collector absent (install failed) - manual ACE dump"

## Checklist (mandatory)

Copy checklist.md (this skill's dir) to
`$ENG_DIR/hunt/ad/<domain>/ad-acl-checklist.md` at run start.
Unchecked at stop = UNCHECKED lane, re-run from the first unchecked
step. SKILL.md and the checklist header agree byte-for-byte on that
copy target.

## Nudge

Review-skill re-injection text (pinned; NOTE: completion-gate emits
its own generic nudge - both mean: resume at the first unchecked box):

    Your work was just reviewed by the review skill and it was found
    that you either missed a step of analysis, or didn't generate an
    artifact of sufficient proof. Look at the markdown based checklist
    and the output for each step, find what you missed, and complete
    that step.

## Confirmation gate

**NOT confirmation:** a BloodHound edge present but never executed
(theoretical); a stale-cache edge the live ACL no longer grants; a
writable GPO the principal cannot link/apply; a group-add that gained
nothing (group grants no privileged nested membership).

**IS confirmation:** the ACL abuse executed END TO END with new
access gained - self-add followed by authenticated access the old
principal lacked; shadow creds/targeted Kerberoast yielding an
authenticating credential; WriteDACL followed by exercise of the
written right; reproduced from your own written steps, with the live
ACL re-checked BEFORE the exercise.

## Methodology

### Step 1 - Collection

    nxc ldap <dc> -u <user> -p <pass> --bloodhound -c all \
      --dns-server <dc> --dns-tcp

No GUI needed: jq over the zip's users/groups JSON lists exactly what
a principal holds rights on ([[bloodhound]]). Manual fallback when
the collector is absent: ldapsearch nTSecurityDescriptor dumps.

### Step 2 - Rights inventory

Per owned principal: GenericAll/GenericWrite/WriteDACL/
ForceChangePassword/AddMember/AddAllowedToAct edges; Tier-0 targets
flagged. LIVE-ACL re-check before any exercise (BH caches go stale
after ACL rebuilds - re-collect or ldapsearch the specific ACE).

### Steps 3-6 - Edge exercise (one probes/<edge>.jsonl each)

- **GenericWrite on a GROUP is a SELF-ADD** - check NESTED membership
  first (the group may sit in Domain Admins through nesting; you
  never touch DA directly). When RPC will not traverse the pivot, add
  yourself with a raw ldap3 MODIFY_ADD on member - and REVERT right
  after the proof. Empty roast/ADCS/delegation surface + explicit
  ACEs on Tier-0 objects = exactly this pattern
  ([[active-directory-access-controls-aclace]]).
- **GenericWrite on a USER**: targeted Kerberoast (write an SPN,
  roast, remove it) or shadow credentials (certipy shadow auto ->
  hands to hunt-ad-adcs).
- **WriteDACL**: write yourself GenericAll on the target, exercise
  the new right once, revert the DACL.
- **ForceChangePassword chains**: walk the reset daisy-chain; when it
  loops or dead-ends, RE-ENUM THE TERMINAL USER'S ATTRIBUTES - the
  winning primitive is frequently an account PROPERTY the ACL graph
  does not surface as an edge: constrained delegation
  (msDS-AllowedToDelegateTo), an SPN (Kerberoastable / RBCD
  -delegate-from), a DCSync right, AdminCount, privileged membership.
  Run on the LAST user you own: nxc --find-delegation,
  impacket-GetUserSPNs, membership re-check. Do NOT conclude "no path
  to DA" off ACL edges alone (a whole box's DA leg was Constrained w/
  Protocol Transition on the chain's terminal user, invisible as an
  ACL edge). Delegation finds hand to hunt-ad-kerberos.

### Steps 7-8 - GPO + ADIDNS

- GPO: writable AND linkable/applicable by the principal (write
  without link rights is a deadend, not a finding). [[active-
  directory-group-policy-objects]].
- ADIDNS: writable DNS nodes -> wildcard/spoof writes where forest
  clients resolve them. [[active-directory-integrated-dns-adidns]].

### Step 9 - Exit

Append ACL rows to $RUN/candidates.jsonl; ACL section of
candidates.md (exercised vs theoretical per edge); `AD-ACL-DONE
edges=<n> exercised=<n> reverted=<n>` appended to
$ENG_DIR/hunt-ad-<domain>.md; _requests.md rows (lane = hunt-ad-acl);
Deadends per theoretical-but-unusable edge.

## Chaining

- Shadow-credentials + cert work: hunt-ad-adcs.
- Delegation attributes found in terminal-user re-enum:
  hunt-ad-kerberos.
- New privileged membership -> re-feed the mapper's enum loop.

## Validation

- Proof = the exercised edge producing access the old principal
  lacked (whoami /groups before/after, authenticated read).
- Negative control: the same action without the write right fails.
- Live-ACL re-check precedes every claim.

## False Positives

- Stale BloodHound edge (ACL since rebuilt) - the live check kills
  this.
- Write rights on objects that grant nothing (inactive account,
  non-privileged group).
- GPO writable but not linkable.
- ADIDNS node writable but no forest client resolves through it.

## Severity

CRITICAL = exercised edge chain to DA-equivalent. HIGH = privileged
group membership gained, shadow creds on sensitive object. MEDIUM =
edge proven, target constrained.

## N/A escapes

- "N/A: nxc absent on VM (install failed)" (manual ACE dumps)
- "N/A: bloodhound collector absent (install failed) - manual ACE dump"
- "N/A: no writable GPOs"
- "N/A: no ADIDNS write rights"
An N/A tick is a claim with a reason, never a silent pass. Identical
strings in SKILL.md and checklist.md.

## Bitter-pill variant

Freehand run: skip checklist + numbered steps, one freehand pass over
the rights inventory, output ONLY $RUN/analysis/bitter-pill.md
(tried/found/dismissed, every claim carries evidence). The
edge-exercised gate and revert discipline survive freehand. Declare
with a _requests.md row (lane = hunt-ad-acl-bitterpill).

### Depth walk (mandatory)

Walk EVERY applicable row of the payload arsenal page cited above.
Record each row in `$RUN/coverage-depth.md` as a table
`| row | state | evidence |` where state is `probed`, `blocked`, or
`N/A`, and evidence is a probe-pair path or a Deadends.md line. A bare
`probed` with no evidence reference fails the completion gate
(NEEDS-REVIEW). N/A rows cite why (surface shape forbids it).

Blocked implies research: before any Deadend is claimable on a blocked
row, (a) walk the arsenal page's bypass-ladder rows for that control
class, and (b) run one wiki query AND one `mcp__wigolo__search` for the
specific tech-plus-control bypass. Results, or a genuine null, land in
`coverage-depth.md`. "No research tried" is not a claimable state.

## Exit artifact + handoff

Appends into the shared mapper $RUN: probes/ad-acl*.{jsonl,md},
raw/acl-inventory.md, raw/bloodhound.zip (under probes/raw/),
candidates.jsonl/md (ACL rows), pointer line AD-ACL-DONE. Consumer:
triage. Findings leave ONLY through G1. Distill: `python3
scripts/wiki-stage.py --kind technique --slug <slug> --target-page
techniques/active-directory/active-directory-access-controls-aclace.md`.

## Stop conditions

All edge steps terminal; every write REVERTED (revert recorded);
nothing written into skill dirs; no unchecked boxes above REVIEW;
hunt-core stop conditions fire unchanged.

## Attack surface

**APPROACH:** Fire the unauth-enum wave at once (null/guest shares + RID-brute, anon LDAP users + description fields, AS-REP roast, person-object SPN Kerberoast, lockout policy, `certipy find -vulnerable`), then walk enum -> roast -> ACL/ADCS ESC1-16 -> delegation -> DCSync -> lateral, reusing captured creds inside the lockout gate.
**AVOID:** A captured-but-uncracked hash, a dumped ticket, a theoretical BloodHound/ESC edge never executed, or an unvalidated spray hit is NOT confirmation - creds must authenticate to the DC (`[+]`/`Pwn3d!`) or the ticket/ACL abuse must be exercised end to end.

## Cross-routing

- Load hunt-windows when you land on a member host for local privesc before DA.
- Load hunt-m365 when the tenant is Entra/hybrid (AD Connect bridge both ways).
- Load hunt-auth for AD FS / cert-based web auth flows.
- Not this skill: plain local privesc with no domain in play (hunt-windows).

