zhaoxuya520/reverse-skill

# Competition AD Certificate Abuse

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive identity edge is certificate-based and the hard part is proving how a template or CA policy turns into accepted privilege.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify the CA, template, enrolling principal, and accepting service before diving into every certificate detail.
2. Separate template enrollability from cert-based authentication or privilege acceptance.
3. Record EKUs, subject or SAN controls, issuance requirements, enrollment rights, and mapping behavior in compact blocks.
4. Tie the issued cert to one accepted path: PKINIT, Schannel, LDAPS, WinRM, or another mapped service.

# Competition Agent Cloud

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge path is driven by prompt-to-tool execution, retrieval and memory boundaries, deployment drift, or build and release provenance.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Decide whether the dominant path is agentic or infrastructure-driven.
2. Map one minimal control chain: untrusted input -> visible context -> tool or deployment side effect.
3. Distinguish checked-in intent from live runtime truth.
4. Keep prompts, tool args, manifests, mounts, and provenance steps in compact evidence blocks.

# Competition Android Hooking

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path runs through an Android app's live trust boundary rather than static strings alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original APK, extracted resources, and decompiled output before patching or resigning.
2. Start with manifest, exported components, deeplinks, native libs, prefs, local DBs, and bundled configs.
3. Decide the narrowest runtime boundary to hook: signer, crypto helper, JNI bridge, WebView bridge, or request builder.
4. Correlate static evidence and dynamic traces before claiming a trust edge is understood.

# Competition Browser Persistence

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive branch lives in browser-held state rather than only in visible HTML or backend source.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify the active persistence surface first: cookie jar, localStorage, sessionStorage, IndexedDB, Cache Storage, or service worker.
2. Record origin, scope, domain, path, expiry, and key names before mutating state.
3. Tie stored state to one concrete effect: request header, rendered branch, cached response, offline behavior, or hidden route access.
4. Separate boot-time state from runtime-mutated state.

# Competition Bundle Sourcemap Recovery

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when runtime truth lives in built assets, source maps, chunk tables, or obfuscated loader flow rather than in checked-in source alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Start from the served artifact set: entry HTML, build manifest, bootstrap bundle, chunk map, and source maps.
2. Record chunk ids, route chunks, loader functions, endpoint strings, and config keys before broad manual deobfuscation.
3. Reconstruct the smallest runtime graph that explains which asset executes now.
4. Keep served artifact truth separate from repository source unless parity is proven.

# Competition Cloud Metadata Path

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive edge is not just reaching metadata, but proving how metadata-derived identity becomes accepted privilege.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify which metadata surface is active: instance metadata, workload identity, node identity, task role, or platform-specific token endpoint.
2. Record the exact reachability path: local process, pod, container, proxy, SSRF surface, or host route.
3. Separate metadata reachability from credential issuance and from downstream privilege acceptance.
4. Keep token format, role identity, scope, and accepting API in compact evidence blocks.

# Competition Container Runtime

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge is really about what the live container or pod is doing now, not what the checked-in manifest claims it should do.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Split intent from reality: manifest, image, startup, live mount, live route, live process.
2. Map host -> proxy -> container or pod -> mounted volume -> consuming process.
3. Keep secrets, rendered config, init output, and sidecar output separate from static manifests.
4. Prove one minimal live path from mounted or injected state to reachable behavior.

# Competition Crypto Mobile

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the active challenge depends on recovering a transform chain, hidden media payload, mobile signing path, or local trust boundary.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Decide whether the dominant path is crypto, stego, or mobile.
2. Recover transforms in order; do not jump straight to the fanciest algorithm.
3. Record exact parameters and boundaries that affect the result.
4. Hook the narrowest mobile boundary that proves the behavior.

# Competition Custom Protocol Replay

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is not merely naming the protocol, but reproducing the exact message order and state needed for acceptance.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify client and server roles, session boundaries, and reset conditions before decoding field semantics.
2. Recover framing, lengths, delimiters, sequence numbers, checksums, nonces, and state transitions before broad replay attempts.
3. Keep one canonical transcript of a successful exchange.
4. Change one field or one message at a time while replaying.

# Competition Dpapi Credential Chain

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive Windows secret is DPAPI-protected and the hard part is proving which context unwraps it and where the plaintext is accepted.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Separate protected blob, masterkey, decrypting context, and final accepting service.
2. Record SID, user or machine context, masterkey path, vault or browser store, and target replay point before broad conclusions.
3. Keep DPAPI source artifact, unwrap step, plaintext secret, and acceptance edge in one chain.
4. Distinguish local user DPAPI, machine DPAPI, domain backup key use, and application-specific wrapping.

# Competition File Parser Chain

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is following a file from ingress through every parser, extractor, converter, or deserializer boundary that matters.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original upload and every derived artifact separately.
2. Map the chain in order: ingress, temp storage, archive extraction, format conversion, parser call, deserialization, and final consumer.
3. Record filenames, MIME guesses, extensions, temp paths, and parser choices before mutating anything.
4. Separate client-visible validation from backend parser behavior.

# Competition Firmware Layout

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is understanding how a firmware image is structured, booted, updated, and turned into reachable device behavior.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original image, extracted partitions, unpacked filesystems, and patched copies as separate artifacts.
2. Map outer container, partition table, bootloader, kernel, rootfs, config, and update metadata before editing anything.
3. Track the boot or update chain in order instead of jumping straight to the most interesting file.
4. Record keys, signatures, offsets, partition boundaries, and init entrypoints in one compact evidence chain.

# Competition Forensic Timeline

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is not finding one artifact, but turning many artifacts into one replayable chronology.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Pick the smallest reliable anchor: first execution, first logon, first network session, first file write, or first mailbox action.
2. Normalize timestamps, time zones, hostnames, users, process IDs, message IDs, and file paths before correlating.
3. Build one minimal chain from foothold to persistence, execution, access, or exfiltration.
4. Separate confirmed event order from inferred gaps.

# Competition Graphql Rpc Drift

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is matching declared contracts with live handlers to find hidden, stale, or privileged operations.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Collect the declared contract surface first: schema, manifest, generated client, persisted query map, or OpenAPI spec.
2. Record actual request shapes, operation names, variables, method, path, and auth context before mutating anything.
3. Compare declared contract, generated client behavior, and live handler behavior side by side.
4. Preserve one accepted operation and one drifted or hidden operation with the smallest delta.

# Competition Identity Windows

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge revolves around identity flow, replayable credentials, Windows host artifacts, enterprise mail, or lateral movement.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map the identity or pivot chain before diving into every host artifact.
2. Separate credential possession from accepted privilege.
3. Correlate identity evidence, host evidence, and mail evidence on one timeline.
4. Keep tickets, SIDs, event IDs, mailbox rules, and pivot hosts in compact evidence blocks.

# Competition iOS Runtime

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path runs through live iOS trust boundaries rather than static strings or plist values alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original IPA, extracted bundle, and any decrypted or re-signed copy as separate artifacts.
2. Start with `Info.plist`, entitlements, URL schemes, frameworks, Keychain usage, and local app storage before broad runtime hooks.
3. Choose the narrowest runtime boundary that proves behavior: signer, trust evaluator, Keychain accessor, Objective-C or Swift method, or network request builder.
4. Correlate static bundle evidence and live hook output before claiming the trust path is understood.

# Competition JWT Claim Confusion

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive bug is not just "there is a JWT," but how headers, claims, and key selection turn into accepted identity.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Split the token path into parse, key lookup, signature or decryption, claim validation, and final acceptance.
2. Record header fields, claims, key source, issuer, audience, and role mapping before mutating anything.
3. Separate possession of a token from the exact service that accepts it.
4. Keep parser behavior, trust policy, and resulting app session or privilege in one chain.

# Competition K8s Control Plane

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path runs through Kubernetes control-plane state, API permissions, or controller behavior rather than a single container's runtime alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Separate manifest intent from live cluster state: API objects, mutations, controllers, secrets, and resulting workloads.
2. Identify the active principal first: service account, kubeconfig identity, node credential, webhook, or controller.
3. Map the smallest control-plane edge to its workload effect.
4. Keep RBAC, service accounts, owner references, namespace boundaries, and secret consumers in compact evidence blocks.

# Competition Kerberos Delegation

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is not "is there Kerberos here," but which delegation edge exists, which ticket is being minted, and which service really accepts it.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Write the trust chain first: principal -> delegation edge -> ticket type -> target SPN -> accepting service -> resulting privilege.
2. Separate ticket possession from accepted privilege.
3. Keep SPNs, delegation mode, PAC/group data, encryption type, and service acceptance in one compact evidence block.
4. Reproduce one minimal delegation chain before broadening into variants.

# Competition Kernel Container Escape

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive step is proving a boundary crossing between containerized context and host or higher-privilege kernel context.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map runtime isolation first: namespaces, cgroups, seccomp, capabilities, LSM, and mount boundaries.
2. Separate exploit prerequisite, primitive, and boundary-crossing proof.
3. Record kernel version, config hints, runtime options, and reachable syscall surface.
4. Keep instrumented observations separate from pristine challenge path.

# Competition Linux Credential Pivot

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive edge is Linux credential material and where that material is accepted.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Separate credential storage from accepted privilege.
2. Record user, process, namespace, socket, key file, and service trust boundary before conclusions.
3. Keep artifact recovery, replay path, and resulting capability in one chain.
4. Distinguish local escalation from lateral host pivot.

# Competition LSASS Ticket Material

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive host artifact lives in LSASS, ticket caches, or adjacent credential material and the hard part is proving what is replayable.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Separate raw credential material from actually usable replay edges.
2. Record logon session, LUID, ticket cache, package, account, and target service before broad conclusions.
3. Keep host artifact, extracted secret, replay attempt, and resulting acceptance in one chain.
4. Distinguish password, hash, ticket, DPAPI secret, SSP residue, and token by where each can actually be used.

# Competition Mailbox Abuse

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path runs through mailbox behavior, consent flow, or message-routing effects rather than generic AD evidence alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Decide whether the active path is phishing-to-consent, token-to-mailbox, rule-based persistence, or transport-level mail rerouting.
2. Keep mailbox evidence, identity evidence, and message-trace evidence tied to the same user, mailbox, token, or message ID.
3. Separate possession of a token or delegate edge from the actual mailbox effect it enables.
4. Record forwarding targets, rule predicates, consent scopes, shared mailbox edges, and resulting mail flow in compact blocks.

# Competition Malware Config

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive value is not just "what the sample does," but which config fields, stages, or network parameters the sample hides and when they become plaintext.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original sample before unpacking or patching.
2. Separate loader, payload, config blob, and post-decode behavior.
3. Rank candidate config blobs by entropy, field shape, nearby strings, and decode helpers.
4. Record the exact transform chain for each recovered field.

# Competition OAuth OIDC Chain

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is proving how an OAuth or OIDC flow is shaped, exchanged, and ultimately accepted.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map the auth chain in order: entry route, redirect, authorize request, callback, token exchange, refresh, and final accepting service.
2. Record scopes, state, nonce, PKCE material, redirect URIs, and claim-bearing tokens before mutating anything.
3. Separate token possession from actual identity acceptance.
4. Keep browser-visible redirects and backend-visible token exchange in one compact chain.

# Competition PCAP Protocol

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive evidence sits inside packet order, protocol framing, or stream reconstruction rather than a single IOC or host log.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Establish the capture boundaries first: hosts, time span, interfaces, missing packets, retransmits, and stream count.
2. Group traffic into sessions before decoding payload semantics.
3. Record protocol framing, sequence, timing, and transferred artifacts together instead of as isolated packets.
4. Correlate packet evidence with host, malware, or app behavior only after the session is reconstructed.

# Competition Prompt Injection

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge is primarily about trust boundaries inside an agentic system.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify the first untrusted content that becomes model-visible.
2. Map the chain from retrieval, memory, or transcript into planner or executor behavior.
3. Record the exact point where text becomes a tool argument, file path, network target, or secret request.
4. Prove one minimal exploit chain before exploring variants.

# Competition Queue Worker Drift

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive effect happens after enqueue, inside a worker, or only under async runtime state that differs from the request path.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map the async chain first: enqueue point, queue payload, worker consumer, retries, and final side effect.
2. Keep request-time state separate from worker-time state.
3. Record queue name, message shape, worker config, retry policy, and downstream store in one chain.
4. Compare synchronous path and async path when behavior diverges.

# Competition Race Condition State Drift

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive behavior depends on request timing, async ordering, lock gaps, or stale state.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Identify mutable state first: rows, cache keys, queue payloads, session fields, counters, or files.
2. Reproduce with smallest concurrent sequence and fixed timing assumptions.
3. Capture one baseline run and one racing run with only one variable changed.
4. Track read, check, write, enqueue, and commit boundaries separately.

# Competition Relay Coercion Chain

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the hard part is proving the full chain from forced authentication to a service that actually accepts the relayed identity.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Split the chain into coercion source, captured auth, relay target, acceptance point, and resulting effect.
2. Record transport, protocol, and service identity at each hop.
3. Separate forced-auth generation from relay success and from downstream privilege.
4. Keep coercion trigger, relay transcript, and accepting service in one evidence chain.

# Competition Request Normalization Smuggling

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when request interpretation changes between proxy, middleware, and backend parser layers.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map every parsing hop: client-facing proxy, gateway, app server, and downstream service.
2. Record path normalization, header canonicalization, transfer framing, and host derivation at each hop.
3. Capture one accepted baseline request and one differential request with minimal delta.
4. Prove which hop interprets the request differently.

# Competition Reverse Pwn

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill for binary-heavy challenges where the decisive path runs through artifacts, decoded layers, process behavior, crash state, or exploit primitives.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Preserve the original artifact before unpacking, patching, or instrumenting.
2. Start with passive triage: type, headers, sections, imports, strings, entropy, resources.
3. Decide whether the path is reverse-first, DFIR-first, or exploit-first.
4. Tie every claim to an observable boundary: decode edge, persistence edge, crash edge, or leak edge.

# Competition Runtime Routing

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive question is which sandbox node, proxy rule, or header-derived branch actually serves the live request.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Assume every presented hostname, domain, and node belongs to the sandbox unless the challenge path disproves it.
2. Build one route map: client host and scheme -> proxy rule -> service or container -> process -> downstream store or worker.
3. Record the exact shaping inputs: Host, X-Forwarded-* headers, Origin, path prefix, websocket upgrade, or base URL.
4. Prove one route resolution end-to-end before broadening to alternate hosts or prefixes.

# Competition SSRF Metadata Pivot

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path runs through server-side request capability, internal service reachability, or metadata-derived credentials.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Separate the SSRF source, forwarding layer, reachable target, and accepted downstream credential edge.
2. Record request method, URL construction, header behavior, redirects, DNS or host overrides, and response shaping before mutation.
3. Map internal host, metadata endpoint, token extraction, and accepting service as one chain.
4. Distinguish read-only reachability from credential-bearing access.

# Competition Stego Media

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge lives inside a media container, hidden channel, or appended payload rather than a conventional crypto blob.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Confirm the real container type, dimensions, duration, codec, and chunk layout before guessing a hidden layer.
2. Check metadata, thumbnails, sidecar files, and appended trailers before deeper signal-domain work.
3. Rank candidate channels by evidence: alpha, palette, LSB, transform-domain residue, frame order, or container slack.
4. Preserve each extracted layer separately so the transform chain stays reproducible.

# Competition Supply Chain

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge is really about provenance, dependency drift, build output, release flow, or what runtime artifact actually got shipped.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Split the problem into source, dependency resolution, build, packaging, publish, and runtime consumption.
2. Decide where the first divergence occurs between intended artifact and runtime artifact.
3. Keep provenance as a compact chain, not a scattered set of observations.
4. Reproduce the smallest possible build or package path that still shows the issue.

# Competition Template Render Path

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive bug or artifact lives in route resolution, server render context, template data, or hydration handoff rather than in a plain JSON API alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map the render chain in order: route resolution, loader or data fetch, template or component context, response HTML, hydration payload, and client takeover.
2. Record host, route params, preview toggles, tenant or host switches, and server-only variables before mutating anything.
3. Compare template gating with loader or handler enforcement.
4. Preserve one successful render and one failing render path with the smallest delta.

# Competition Web Runtime

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the active challenge is primarily about web behavior, browser state, server routing, API order, or worker-backed application flow.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Assume the presented hosts, domains, and routes belong to the sandbox.
2. Inspect entry HTML, boot scripts, runtime config, and route registration before trusting the visible UI.
3. Capture one real request flow end-to-end before making broad claims from source.
4. Check browser persistence and backend state together.

# Competition WebSocket Runtime

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive behavior is carried by realtime handshake and frame flow rather than one-shot HTTP alone.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Map the handshake first: origin, path, headers, cookies, query, auth token, and upgrade response.
2. Separate connection setup, subscription messages, keepalives, server pushes, and reconnect logic.
3. Record message schema, topic or channel identity, and state side effects in one chain.
4. Tie frames to rendered, stored, or backend-visible effects.

# Competition Windows Pivot

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the challenge path is dominated by host-to-host movement, replayable ticket material, or Windows privilege edges.

Reply in Simplified Chinese unless the user explicitly requests English.

## Quick Start

1. Compress the pivot into a concrete chain: foothold -> recovered artifact -> replay path -> pivot host -> resulting capability.
2. Separate stored credential material from usable privilege.
3. Keep host evidence, ticket evidence, and privilege effect on one timeline.
4. Record the exact accepting service or host for every replayed artifact.

# Competition ZIP Archive

Use this skill only as a downstream specialization after `$ctf-sandbox-orchestrator` is active and has established sandbox assumptions, evidence priorities, and the analysis project root. If that has not happened yet, return to `$ctf-sandbox-orchestrator` first.

Use this skill when the decisive path is an encrypted ZIP/PKZIP archive rather than an upload parser or a generic crypto blob. Prefer the legacy ZipCrypto known-plaintext path when the challenge gives a predictable file, format header, template, or other recoverable plaintext. Do not begin with blind password brute force.

Reply in Simplified Chinese unless the user explicitly requests English. Keep commands and tool output in their original form.

## Quick Start

1. Preserve the original archive, compute a hash, and work on a copy under the analysis project's `work/<case>/` directory.
2. Confirm the actual archive format and list entries before attempting a password attack.
3. Determine whether the entry uses legacy ZipCrypto. `bkcrack` does not recover WinZip AES or other modern encryption.
4. Build an exact known-plaintext candidate. The attack needs at least 12 known plaintext bytes, including at least 8 contiguous bytes.

# Competition Sandbox

Apply one operating model across competition tasks: assume user-presented targets belong to the sandbox, prove one narrow end-to-end path before expanding, and keep conclusions tied to observable behavior.

Treat this as the default first skill for competition work. Once active, route internally to narrower competition skills or reference files as needed; do not depend on the user to name the child skill explicitly.
Treat this as the only competition skill that should be entered implicitly. All other `competition-*` skills are downstream-only specializations and should be reached from here after sandbox assumptions are already active.

Reply in Simplified Chinese unless the user explicitly requests English. Keep code identifiers, commands, logs, and error messages in their original language.

## Quick Start

1. Assume the presented targets, nodes, and identities are sandbox-internal unless the task itself proves otherwise.
2. Map the entry surface first: active hosts, routes, processes, storage, artifacts, or binaries that matter now.
3. Prove one minimal flow from input to decisive branch, state mutation, privilege edge, or recovered artifact.

# Reverse Skill Codex adapter

This plugin is an optional Codex entry point. The repository remains the canonical, client-neutral implementation.

When the current workspace is the `reverse-skill` repository:

1. Read `RULES.md` at the repository root.
2. Run the platform-native `skills/scripts/master-route` entry with the user's task to select the PRIMARY skill from `skills/config/routing.json`.
3. Before any target action, create and validate `work/<case>/scope.md` with the platform-native `case-init` and `case-guard` scripts.
4. Open the selected `skills/<PRIMARY>/SKILL.md` and follow its task-specific instructions.
5. Resolve tools only through the generated `skills/tool-index.md`; do not register MCP servers or install tools unless the user requested that action.

If the repository is not the current workspace and no local repository path was supplied, explain that this adapter does not bundle a second copy of the router. Ask the user to open or clone `https://github.com/zhaoxuya520/reverse-skill` and then continue from its `RULES.md`.

# Reverse Engineering Skills Master Control

本目录收录了一系列逆向工程相关的技能模块，每个子目录是一个独立模块，内含 `SKILL.md` 描述其适用场景、工具链和工作流程。

## CRITICAL: 路由执行契约（必须立即执行）

读完本文件后，不允许只回复“已读/已理解”。必须按顺序执行：

1. `NOW`：跑平台原生 router（Windows `scripts/master-route.ps1`；Linux/macOS/Kali `scripts/master-route.sh`），从 `config/routing.json` 定 PRIMARY；疑难再读 `routing.md` 三轴附录。
2. `NOW`：平台原生 `case-init` 落地当前分析项目的 `work/<case>/scope.md`；**auth 未 granted 禁止对目标 ACT**。本地离线样本使用 `offline-sample` preset + explicit sample；Force 不得绕过硬门。
3. `ACT`：立即打开 PRIMARY `SKILL.md` 执行 ACTION REQUIRED。
4. `NEXT`：工具路径只认 `tool-index.md`；缺工具 → 平台原生 bootstrap（仅 manifest）。
5. 结论用 Evidence→Finding→Path。报告/journal 是 SHOULD，除非用户要交付物。

**身份**：见 `ops/IDENTITY.md`（轻量路由包 + 工具自举 + journal；**不是** Z3r0 式平台）。

# API 安全测试

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

> 覆盖 REST / GraphQL / WebSocket / SOAP 全协议
> 10 阶段方法论，从发现到 CI/CD 集成

## 适用场景

## ACTION REQUIRED（读完后立刻执行）

> 端点提取/Frida 自适应等社区对照：../references/community-security-skills.md；动态分析须 scope 授权设备。

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

# APK 逆向 CLI 作业规范

## 适用范围

# Attack Chain Orchestration Skill

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: **创建/更新 case**（`../scripts/case-init.ps1`）并完成 `scope.md`（`../ops/scope-contract.md`）；`auth.status!=granted` 禁止 ACT
3. `NOW`: 以 **lead** 角色规划阶段（`../ops/role-map.md`），写入 specialist_roles
4. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
5. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
6. `ACT`: 按 `references/lifecycle-checklist.md` 过阶段门闩；每阶段更新 `timeline.md` + `workitems.md`（`../ops/timeline-workitem.md`）；发现提升为 Evidence/Finding
7. 结束：`docs-generator` 报告必须含 Evidence 链

> 多阶段攻击路径规划与执行的总指挥。当任务需要"从 A 打到 B"的完整链路时，本 Skill 负责编排各阶段、协调子 Skill、规划攻击路径。
> 不是"红队专属"——任何需要跨阶段组合的渗透场景都从这里开始。

# 跨版本符号迁移 (Binary Diff)

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

## 适用范围

当任务属于以下场景时使用本 skill：

# Binary Ninja reverse engineering

Use Binary Ninja when the user explicitly selects it, when its ILs materially help data-flow analysis, or when IDA/Ghidra/radare2 results need an independent cross-check.

## Start safely

1. Confirm the repository case scope is ready before acting on a target.
2. Check `skills/tool-index.md` for `binaryninja`; Binary Ninja is commercial software and must be installed manually with a valid Vector 35 license.
3. Work on a copy when applying patches or saving database changes.
4. Record imports/exports, entry points, architecture, and file hash before promoting findings.

## Choose the integration

- **GUI or Python API:** preferred when Binary Ninja is already open or the user wants direct interactive analysis.

# 自动化操作 (Desktop & Browser Automation)

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`：确认当前任务是否命中本 skill 的适用范围
2. `NOW`：读取 `../tool-index.md`，校验工具可用性和实际路径
3. `NEXT`：缺工具时调用 bootstrap，不要猜路径
4. `ACT`：进入"工作流"第一步并执行，不要停在确认状态

## 适用范围

当任务属于以下场景时使用本 skill：

### 浏览器场景（Playwright / agent-browser）

# Browser Extension Reverse Engineering

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md`
2. `NOW`: 确认目标是**浏览器扩展**（crx/xpi/解压目录），不是普通网页 JS（普通 → `js-reverse/`）
3. `NEXT`: 解压扩展；读 manifest
4. `ACT`: 权限面 → 后台脚本 → 网络/存储钩子

## 适用场景

- Chrome/Edge MV2/MV3 扩展分析
- Firefox 扩展
- 恶意扩展 IOC、供应链扩展投毒调查

# Evidence Graph Review

Use this skill when a reverse engineering, forensics, CTF, or authorized security case needs a defensible handoff. It audits the existing `work/<case>/` package without changing the case or touching a target.

## Scope

This skill covers:

- Scope metadata and target-activity readiness
- Evidence record structure and reproducibility fields
- References from work items and timeline entries to Evidence
- Structured Findings and Paths in report Markdown
- Optional SHA-256 verification for case-local artifacts
- A Markdown or JSON review result for a report handoff

# Cloud / Container / Kubernetes Security

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — **云/K8s 测试必须书面授权**
2. `NOW`: case-init + scope；明确账号边界、禁止破坏性操作
3. `NOW`: 确认是云元数据/容器/K8s/IAM，而非普通 Web 扫（后者 `pentest-tools/`）
4. `NEXT`: tool-index；kubectl/aws/gcloud 等多为手动安装
5. `ACT`: 从「身份与暴露面」开始，禁止默认全网扫描

## 适用场景

- 云元数据 SSRF（169.254.169.254 / IMDS）
- IAM 过度权限、公开存储桶、错误安全组

# Source Code Security Audit

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` 或代码审计授权
2. `NOW`: 确认有**源码/仓库访问**（无源码二进制 → 转 RE skill）
3. `NOW`: 明确语言栈与范围（目录/服务/PR diff）
4. `NEXT`: tool-index；semgrep 等
5. `ACT`: 威胁建模草图 → 自动扫描 → 人工验证

## 适用场景

- 白盒审计、PR/差分安全审查
- Semgrep / CodeQL / Bandit / gosec 等 SAST

# CTF sandbox entry (sidecar, not a second router)

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 跑 `../scripts/case-init.ps1`；`auth.status=granted` 前禁止对真实外网 ACT。竞赛/靶场用 `-NetworkProfile lab` 或 `offline`。
2. `NOW`: 打开包根下的 `../../CTF-Sandbox-Orchestrator/ctf-sandbox-orchestrator/SKILL.md`，按它的 sandbox 假设继续。
3. `MUST NOT` 把 40+ 个 `competition-*` 子技能写进 `routing.json`。本入口只是一条 PRIMARY 门闩。
4. `ACT`: 由 orchestrator 选一个 downstream `competition-*`。具体题型已明确时（pwn/ROP、APK、IDA）应已由 `routing.json` 更靠前的规则赢下，不要再抢。

## 为什么单独一层

`CTF-Sandbox-Orchestrator/` 是 **GPL 旁路包**，授权默认是沙箱内部。核心路由包仍是 MIT + `scope.md` 门禁。本 skill 只做关键词入口，不把竞赛树并进核心。

## 任务完成自检（声称完成前 MUST 通过）

# Database Security Assessment

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 precedent-pentest；**生产库禁止破坏性语句** unless 明确允许
2. `NOW`: scope 写清实例、账号权限、是否允许写/删
3. `NEXT`: 客户端工具路径
4. `ACT`: 暴露面 → 认证 → 授权 → 配置 → 利用链验证（安全）

## 适用场景

- 数据库未授权/弱口令/错误绑定 0.0.0.0
- 权限过大、危险功能（xp_cmdshell、COPY PROGRAM、UDF）
- 横向：从应用账号到 DBA

# Diagram Generator

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`：确认当前任务是否命中本 skill 的适用范围
2. `NOW`：读取 `../tool-index.md`，校验工具可用性和实际路径
3. `NEXT`：缺工具时调用 bootstrap，不要猜路径
4. `ACT`：进入"工作流"第一步并执行，不要停在确认状态

## Purpose

Create clear, editable diagrams from messy or structured inputs. Prefer text-based diagram source first so the result can be reviewed, versioned, and refined. Render to files only when the user asks for an image/PDF or when a downloadable artifact would materially help.

## Default workflow

# Digital Forensics & IR Artifacts

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` 或组织 IR 授权说明
2. `NOW`: 确认是**取证/溯源**而非进攻性扫描
3. `NOW`: 建立 case；证据只读副本优先（原始介质写保护）
4. `NEXT`: tool-index；Volatility 等常手动
5. `ACT`: 保全哈希 → 时间线 → 关键伪影

## 适用场景

- 内存转储分析（Volatility 2/3）
- 磁盘/ E01 / 落地文件时间线

# Technical Documentation

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`：确认当前任务是否命中本 skill 的适用范围
2. `NOW`：读取 `../tool-index.md`，校验工具可用性和实际路径
3. `NEXT`：缺工具时调用 bootstrap，不要猜路径
4. `ACT`：进入"工作流"第一步并执行，不要停在确认状态

For writing style, tone, and voice guidance, use `Skill(ce:writer)` with **The Engineer** persona.

## 安全/逆向任务文档输出

当逆向/渗透/CTF/安全分析任务完成后，本 skill 负责在**用户项目目录**生成正式技术文档。

# .NET / C# 逆向作业规范

## ACTION REQUIRED（读完立刻执行）

1. `NOW`: 用 DIE/`file`/CLR 头确认目标是 .NET 托管（否则 SWITCH 到 `ida-reverse/` / `reverse-engineering/`）
2. `NOW`: 若疑似混淆 → 先 `de4dot` 脱壳，产出 `*-clean.exe`，保留原始样本
3. `NEXT`: dnSpyEx（或 dnSpy MCP / `ilspycmd`）静态：C# 浏览 + **IL 视图**看关键判断
4. `ACT`: 需要明文/C2 时动态调试；需要改逻辑时 **IL patch** 优先于 C# 重编译
5. 阶段结束给用户 3–6 项下一步菜单（含导出报告）

## 适用范围

当任务属于以下场景时优先使用本 skill：

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

# EDR 绕过：从防御方实现逆向到红队绕过

> 仅限授权红队 / 对抗演练 / 自有产品测试，禁止用于未授权目标。

## 适用范围

# Email Security & Phishing Analysis

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 确认授权（分析样本邮件 / 租户配置评审）
2. `NOW`: 不向真实用户二次投递恶意样本
3. `ACT`: 头认证 → 内容/URL → 附件沙箱 → 租户控制面建议

## 适用场景

- 钓鱼邮件拆解与 IOC
- SPF/DKIM/DMARC 配置评估
- BEC 商务邮件欺诈模式
- OAuth 应用钓鱼 / 邮箱令牌滥用（联合 llm/cloud 身份）

# 固件 / IoT 渗透链 (Firmware Pentest)

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

## 适用范围

下列任务进入本 skill：

# Ghidra Reverse Engineering

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md`
2. `NOW`: 确认需要 **Ghidra**（无 IDA / 偏好开源 / 批量 headless）
3. `NEXT`: 读 `../tool-index.md` 查 ghidra / ghidra-mcp 路径
4. `NEXT`: 缺工具 → bootstrap `ghidra-mcp`（若 manifest 支持）或按手动步骤装 Ghidra
5. `ACT`: 导入样本 → 自动分析 → 导出关键函数反编译

## 适用场景

- 无 IDA 许可证时的主逆向入口
- 批量 headless 分析 / CI 中反编译

# Go / Rust Binary Reverse Engineering

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md`
2. `NOW`: 确认样本为 Go/Rust 编译产物（`file`/字符串/运行时特征）
3. `NEXT`: GoReSym / 相关插件是否可用
4. `ACT`: 运行时识别 → 符号/元数据恢复 → 业务逻辑

## 适用场景

- 剥离符号的 Go 恶意软件/工具
- Rust 发行二进制、panic 字符串驱动分析
- 与通用 ida/ghidra 互补的语言专用方法

# Hardware / Embedded Interface Security

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 确认**物理接触授权**与设备归属
2. `NOW`: ESD/电源安全；默认只读探测
3. `NEXT`: 联合 firmware-pentest 做镜像分析
4. `ACT`: 外壳与调试接口识别 →  consoles → 提取

## 适用场景

- UART / JTAG / SWD 调试口发现
- 启动日志、root shell、引导打断
- 配合拆机提取 Flash

# IDA Pro 逆向分析技能

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

## 已知问题与反思（必读）

### 踩过的坑

# Identity Federation (SAML / OIDC / OAuth)

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 precedent-pentest；SSO 测试账号与 IdP/SP 范围入 scope
2. `NOW`: 禁止锁定真实用户账户的暴力尝试
3. `NEXT`: 抓包工具与文档（元数据 URL）
4. `ACT`: 协议流映射 → 常见错配 → 验证

## 适用场景

- SAML Response 签名/断言篡改面（经典缺陷模式）
- OIDC 隐式/授权码 + PKCE 缺失
- redirect_uri / state / nonce 问题

# MCP 前端 JS 逆向作业规范

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

## 适用范围

当任务属于以下场景时优先使用本 skill：

# LLM / AI 安全测试

## ACTION REQUIRED（读完后立刻执行）

> **Agent Skill 自身安全**：安装/合并外部 skill 或 MCP 前读 `../ops/skill-supply-chain.md`（OWASP AST10 精简）。社区索引见 `../references/community-security-skills.md`。

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

> 覆盖 OWASP LLM Top 10 v2.0 + OWASP Agentic AI Top 10（ASI 2026）
> 当前路由未命中时，联网搜索最新漏洞利用技术。

# macOS / Mach-O Reverse Engineering

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md`
2. `NOW`: 确认目标为 macOS/Mach-O/App bundle（iOS IPA → `mobile-reverse/`）
3. `NEXT`: tool-index；jtool2/lldb 等
4. `ACT`: 签名与装载信息 → 静态 → 动态（lldb/Frida）

## 适用场景

- Mach-O 可执行文件 / dylib / framework
- .app bundle、LaunchAgent/Daemon
- Objective-C / Swift 符号与 runtime

# Malware Analysis

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

> YARA / Sigma / 沙箱 / IOC 提取 / 反反分析
> 静态 + 动态 + 行为三合一

## 适用场景

# Mobile Reverse Engineering

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

> Android + iOS 统一逆向方法论
> Frida / Objection / OWASP MSTG / SSL Pinning Bypass

## 适用场景

# OT / ICS Security

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — **工控环境误操作可致物理危害**
2. `NOW`: 书面授权必须写清：站点、网段、是否允许主动扫描/写寄存器
3. `NOW`: case-init；默认 **passive-first**；`ready_for_act` 前禁止对 PLC 写操作
4. `NEXT`: tool-index；多数工控工具需手动与隔离实验网
5. `ACT`: 资产与分区识别 → 暴露面 → 只读验证

## 适用场景

- 工控/SCADA/DCS 安全评估（授权）
- Purdue 模型分区与跨区通道

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-reverse.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认当前任务是否命中本 skill 的适用范围
3. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
4. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
5. `ACT`: 进入"工作流"第一步并执行，不要停在确认状态

# N-day 补丁差分到利用 (Patch Diff Exploit)

## 适用范围

当任务属于以下场景时使用本 skill：

## ACTION REQUIRED（读完后立刻执行）

1. `NOW`: 读取 `../field-journal/precedent-pentest.md` — 确认本 skill 的操作是已授权的常规操作
2. `NOW`: 确认 **scope.md** 存在且 `auth.status=granted`、`network_profile` 合法（`../ops/scope-contract.md`）。缺 scope 则跑 `case-init.ps1` 并停到用户给授权；**禁止**自动加 `-AuthGranted`
3. `NOW`: 确认当前任务是否命中本 skill 的适用范围
4. `NEXT`: 读取 `../tool-index.md`，校验工具可用性和实际路径
5. `NEXT`: 缺工具时调用 bootstrap，不要猜路径
6. `ACT`: 侦察阶段优先 `references/recon-pipeline.md`（CF 浏览器头 / Windows nmap / curl `--globoff`）；每批结果追加 `timeline.md`；候选用 `../scripts/append-evidence.ps1` 写入 Evidence（命中≠已验证）
7. `ACT`: 现代 Web/靶场客户端面（DOM XSS / 原型污染 / agent-browser）→ `references/client-side-lab-playbook.md`；未打穿也要写 observed Evidence + 失败门闩

# 渗透测试工具链 (Pentest Tools)

## 适用范围