ljagiello/ctf-skills: Agent Skills for Automated CTF Challenge Solving

What ctf-skills Is and Who It Is For

Capture the Flag competitions require competitors to solve security challenges across categories such as web exploitation, binary exploitation, cryptography, reverse engineering, forensics, and OSINT. Each category demands different tools and techniques, and setting up a working environment while under competition time pressure takes time away from actual solving.

ctf-skills packages Agent Skills for solving these challenges. According to the README, it works with any tool that supports the Agent Skills specification, including Claude Code. Installing the package gives an AI agent access to categorized skill files that describe specific techniques, tool usage patterns, and attack strategies for each challenge category.

The repository is maintained by ljagiello, with a last push on 2026-09-13. The homepage is at ljagiello.github.io/ctf-skills. The license is MIT.

Installing ctf-skills and the Skills Specification

The package installs through the npx skills CLI:

npx skills add ljagiello/ctf-skills

This command fetches the skill definitions and makes them available to any Agent Skills-compatible tool in the local environment. The Agent Skills specification at agentskills.io defines how a tool like Claude Code discovers and invokes skill files, so ctf-skills follows that protocol rather than defining its own integration layer.

Each skill category's SKILL.md file contains a Prerequisites section that lists the tools needed for that category. This supports an on-demand installation model where tools are installed as the agent encounters them. For competition use, the README recommends pre-installing everything before the competition begins rather than installing on demand, since network access is not always available during events.

The project requires Python 3.12 or later. The pyproject.toml uses ruff for linting with rules E, F, W, and I selected, and pytest for running the test suite.

Environment Setup: Pre-install vs. On-Demand

The README describes two tool installation strategies. The pre-install approach uses a central installer script that handles all tool groups at once:

bash scripts/install_ctf_tools.sh all

For narrower installations, specific tool groups can be targeted:

bash scripts/install_ctf_tools.sh python
bash scripts/install_ctf_tools.sh apt
bash scripts/install_ctf_tools.sh brew

The supported modes are python, pat, apt, brew, gems, go, and manual. The pat mode is notable: it shallow-clones PayloadsAllTheThings into ~/.ctf-tools/PayloadsAllTheThings and links it for use by the web exploitation skills. Bulk payloads stay outside the repository.

Before a competition, verify what is already installed with:

bash scripts/install_ctf_tools.sh --verify

To preview what would be installed without actually installing anything:

bash scripts/install_ctf_tools.sh --dry-run all

Install logs are saved to ~/.ctf-tools/. The --force flag reinstalls everything regardless of what is already present.

Skill Categories and Their Coverage

The repository organizes skills into eight active categories. The ctf-web skill (22 files) covers SQL injection techniques including blind boolean, time-based, and error-based variants, WAF bypass methods, XSS including AngularJS sandbox escapes and CSP bypasses, SSRF, XXE, file upload polyglots, JWT attacks, OAuth vulnerabilities, and prototype pollution. A parity module for Burp Intruder provides synchronous and async fuzzing options.

The ctf-pwn skill (18 files) includes buffer overflow, ROP chains including ret2csu and ret2vdso, heap exploitation techniques such as House of Force, House of Apple 2, House of Tangerine, and glibc 2.39 tcache key protection, five pwntools template scripts with yield-based payload generators, and kernel exploitation patterns including io_uring CVE-2024-0582 and CET Shadow Stack signal-frame bypass.

The ctf-crypto skill (19 files) covers RSA attacks including small exponent, Wiener's attack, Boneh-Durfee, Hastad broadcast with Coppersmith, and a range of fault and timing attacks; AES modes including ECB byte-at-a-time, CBC padding oracle, and GCM nonce reuse; and ECC attacks covering invalid curve, Smart's p-adic lift, MOV pairing, and ECDSA nonce reuse. Lattice-based and PRNG attacks are also included.

The ctf-reverse skill (19 files) addresses binary analysis, custom VM bytecode lifting to LLVM IR, WASM, RISC-V, Rust serde, Python bytecode, Unicorn CPU emulation with MMIO peripherals, Go binaries using GoReSym, Android APK and DEX, anti-debug, anti-VM, and control flow flattening deobfuscation.

The ctf-forensics skill (14 files) covers disk and memory forensics, RAID 5 XOR recovery, APFS snapshot recovery, steganography techniques including Arnold's Cat Map descrambling and SSTV demodulation, network capture analysis, TLS decryption via keylog, RDP session decryption, USB HID decoding, UART decode, and side-channel power analysis. The ctf-osint skill (3 files) addresses social media, geolocation, Shodan fingerprint deanonymization, and Overpass Turbo spatial queries.

The AI and ML Attack Skill

ctf-skills includes a ctf-ai-ml category covering attacks on machine learning systems. The README lists techniques for model weight perturbation negation, adversarial examples using FGSM, PGD, and C&W attacks, a foolbox L1BasicIterativeAttack implementation, hand-rolled Keras FGSM via K.gradients, prompt injection, LLM jailbreaking, model extraction, membership inference, neural network collision, LoRA adapter exploitation, gradient descent inversion, data poisoning, backdoor detection, token smuggling, and context window manipulation.

This category reflects the growing presence of AI-themed challenges in modern CTF competitions, where organizers include challenges that require understanding of how neural networks can be attacked or manipulated. The skill files describe specific tool usage and attack patterns rather than general concepts, so they are intended to augment a solver who already understands the underlying technique.

Limitations: Scope and Tool Dependencies

ctf-skills provides technique descriptions and tooling guidance, not complete automated solvers. The agent uses the skill files as a reference while working through a challenge; it does not guarantee successful exploitation. The skill coverage is broad but not exhaustive for every challenge variant a competition might include.

The tool setup script pulls packages from apt, brew, pip, gem, and go, as well as manual installs. A competition environment without internet access or with restricted package managers may not be able to complete the full installation. The ctf-pwn skills specify pwntools version 4.15.0 in the template scripts; version drift in pwntools can affect whether the scripts function as written.

The on-demand installation model has a practical problem: if the agent encounters a missing tool mid-challenge, it must stop solving to install it, which interrupts the workflow. The README explicitly recommends pre-installing for competitions. This places a preparation burden on the user before each event.

Alternative: Manual Tool Configuration vs. Skill-Based Approach

Before agent skill packages like ctf-skills existed, CTF competitors typically maintained their own dotfiles, Docker containers, or virtual machines with pre-installed tools and personal technique notes. That approach gives full control over the environment and does not depend on a third-party package keeping its technique files current.

The skill-based approach trades that control for a curated, structured technique library that an agent can reference during a live session. The practical difference is that ctf-skills aggregates techniques across many categories that a single competitor might not have personally written notes for, particularly niche areas like USB HID decoding, CSIDH lattice attacks, or Go binary analysis. The value is higher for generalist competitors who work across all categories than for specialists who focus on one or two.

Editorial conclusion

ctf-skills is a good match for CTF competitors who already use Claude Code and want to accelerate their challenge-solving workflow with pre-written technique files covering a broad range of categories. It is not a beginner resource for learning CTF concepts from scratch; the skill files assume familiarity with the underlying techniques. Before a competition, run install_ctf_tools.sh with --verify to confirm the required tools are present, since missing dependencies will stall the agent mid-challenge.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. ljagiello/ctf-skills on GitHub
4. Project website
5. README