More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Anti-Reversing Techniques: Authorized Analysis Playbook

    1

    Recognize and work through software self-protection during authorized analysis: debugger detection, VM checks, packing, and tamper responses — one layer at a time, with every bypass documented.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Anti-Reversing Techniques: Authorized Analysis Playbook

    Anti-Reversing Techniques: Authorized Analysis Playbook

    Example session with this skill installed

    A Windows malware sample exits within a second when launched under a debugger, but runs for minutes without one. Scope: authorized malware analysis in an isolated VM, written authorization on file. Identify the protection and get it running under the debugger.

    • Read your context and instructions
    • Compiled the anti-reversing techniques

    ANALYSIS — two protection layers found and bypassed; the sample now runs under the debugger to its network behavior.

    Layer 1 — static triage: section entropy normal, imports ordinary, but strings contain debugger references and a suspicious NtQueryInformationProcess import. No TLS callbacks. Verdict: debugger detection, not packing.

    Behavioral confirmation: breakpoint on NtQueryInformationProcess. The sample calls it with ProcessDebugPort within 200ms of start, then exits. The call before death names the check. Walking back from the call: the return value feeds a test eax, eax and a conditional jump to an exit routine. Check and response are separate, as expected.

    Bypass (per the principles — patch the answer, not the question): a debugger breakpoint on the API's return forces the return value to zero (clean), leaving the call intact. Dynamic, reversible, no disk edit.

    Re-run: the sample now runs under the debugger. Twenty seconds in, it exits again — a second layer. It calls RDTSC twice around a short loop and compares the delta. Layer 2 identified: timing check. Calibrated, not killed: the loop's latency measured at startup over five samples (mean 41,000 cycles, max 58,000), threshold set to mean plus margin. Re-run: the sample runs to its network behavior, which is what the analysis actually needed.

    Report entry: both protections documented with locations, triggers, bypasses, and a note that the binary stayed stable after both — plus the observation that the timing layer only appeared after the first bypass, which is why one-layer-at-a-time matters.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Protections exist in layers, and they fall in layers. This skill teaches the identification workflow and the bypass principles for software self-protection during authorized analysis — malware samples, CTFs, authorized pentests, and security research. It is strictly scoped: written authorization is a precondition, and the skill opens with that boundary.

    It covers the four families: debugger detection (PEB flags, NtQueryInformationProcess, RDTSC timing checks, ptrace self-attach), VM and sandbox detection (CPUID hypervisor bit, vendor strings, missing user artifacts), packing and obfuscation (UPX and custom packers, control-flow flattening, string encryption, API hashing), and tamper response (integrity checks, breakpoint scans, delayed punishment branches). For each family there is a family identification table and a bypass decision table.

    The workflow is static triage first (entropy, imports, strings, TLS callbacks), behavioral confirmation (which API fires just before death), locating the decision point (the conditional jump after the check), then classifying and recording before any bypass. The bypass principles: patch the answer, not the question; trace the detected branch before neutralizing it; prefer dynamic hooks over static hex-edits; one layer at a time; calibrate timing checks from measured latency instead of hardcoding thresholds. Platform notes cover x86 vs ARM, Windows, Linux, and macOS. Every protection found gets a report entry: technique, family, location, trigger, bypass, and whether the binary stayed stable.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.

    • Dual-use by nature: it assumes the user has the right to analyze the target. Without authorization, the techniques must not be used.
    • Virtualization-based obfuscators (custom bytecode VMs) need a dedicated deobfuscation effort this skill does not cover in depth.
    • Timing-check calibration depends on the analysis machine; thresholds measured on one host may not transfer to another.
    • Some protectors re-check continuously; a bypass that works at startup may need to stay active for the whole session.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    Permissions

    No special permissions declared or detected

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    On malware samples, in CTFs, under an authorized pentest scope, or on software you own — yes, with written authorization. Bypassing protections on software you have no right to analyze may violate the CFAA, DMCA anti-circumvention rules, or local equivalents. Confirm scope in writing first.

    Downstream code may depend on the check's side effects. Forcing the return value to "clean" leaves the call intact and keeps execution stable; NOP-ing the call can corrupt state the program later needs.

    Probably a delayed tamper response: the integrity check fired earlier and the punishment branch corrupted state minutes later. Look for integrity checks you haven't found yet, and work one layer at a time so each crash is attributable.

    New in Security