Sunday, November 15, 2026

.context for turning AI agents into structured security auditors

.context for turning AI agents into structured security auditors

.context packages a curated library of SKILL.md-format auditing skills, goals and dynamic workflows that let authorized professionals point AI agents like Claude Code, Copilot and Gemini at pentests, smart-contract audits and defensive hunts.

Toolforefy/.context — an MIT-licensed collection of AI agent skills, goals and dynamic workflows for security auditing
CategoryAI agent skills / prompt-engineering toolkit for offensive and defensive security work
Primary UseLoading portable, tool-agnostic auditing methodologies into Claude Code, Copilot, Gemini, Codex and other agents so a request like audit this contract produces a structured, multi-agent triaged report
Safe UseFor authorized penetration tests, bug bounty scopes with confirmed ceilings, internal audits of owned code and infrastructure, and blue-team threat hunting in security labs
Telemetry NoteSkills are largely passive documents, but several (ssrf-oob, cloud-bucket-brute, external-enumeration) direct the agent to send real probe traffic to targets; on owned or monitored environments this appears as OAST DNS/HTTP callbacks, bucket HEAD requests, and multi-source subdomain enumeration, all visible to defenders as reconnaissance noise

.context is a Python-flavored repository from forefy that bills itself as an optimized collection of AI agent skills, goals and workflows for security auditing, and it is one of the older efforts by security researchers to move auditing knowledge directly into the agent layer rather than leaving it in wikis and checklists. The format is the decisive design choice: every skill follows the Agent Skills Format documented by Claude, meaning each capability lives as a SKILL.md file at a path like skills/<category>/<name>/SKILL.md. That structure makes the whole library portable across Claude Code, Copilot, Gemini, Codex, Hermes Agent and OpenAI-backed agents, which is why the README leads with a row of agent logos rather than a CLI screenshot. At roughly 153 stars and an MIT license, it reads as a working researcher's toolkit, not a product pitch.

Installation is deliberately agent-native. The README's suggested path is to paste a single instruction into your chat: Run the AI Security Registry installation wizard https://github.com/forefy/.context/blob/main/install.md. A manual alternative exists — the same data is mirrored at forefy.com/aisecurity, where skills can be searched and downloaded individually through an easy-install button. That two-path approach tells you something about the intended audience: people who want the whole registry wired into their agent, and people cherry-picking one skill for a specific engagement. It also means the repository functions as a registry, with the site acting as a browsable index over skills/.

Discovery inside the repo is flat, and the README is explicit that the category folders under skills/ exist for human organization only — an agent resolves any skill by its directory regardless of grouping. This is a smart architectural call, because it decouples the taxonomy (which changes as new domains are added) from the lookup mechanism an agent actually uses. The categories currently cover applicative-pentest, blockchain, cloud, llms, hunter-utils, generic-utils and defensive, and each skill ships with runnable snippets plus the wordlists, regexes and thresholds either inline or in a references/ folder. In practice that means a skill is closer to a mini-methodology than a prompt: it encodes not just what to check but the decision thresholds that turn an observation into a finding.

The applicative-pentest folder is the most conventionally offensive set, and notably it is tool-agnostic by design — the README emphasizes curl/python3 with no scanner required. Skills include ssrf-oob (an out-of-band SSRF probe that injects OAST/collaborator callbacks into forwarding parameters and client-IP headers and waits for the DNS or HTTP interaction that proves a blind server-side request), http-request-smuggling (raw-socket CL.TE and TE.CL desync detection with timing probes and differential-response confirmation), jwt-attacks (testing signature validation weaknesses including alg:none, signature stripping, kid traversal, jwk/jku injection and RS256/HS256 confusion), broken-access-control (identity-swap and incremented-object-id replay with response-diff thresholds), and webapp-probe, which splits into passive analysis of captured traffic and active checks for exposed files, Wayback endpoints and dependency-confusion surfaces. The emphasis on captured-traffic replay rather than blind crawling is a marker of an authorized-testing posture baked into the methodology itself.

The blockchain category reflects the maintainer's apparent specialty. smart-contract-audit is a full audit framework with multi-expert analysis for Solidity, Anchor, Vyper, TON (FunC/Tact) and Sui (Move), each with language-specific checks and vulnerability-pattern references. foundry-poc is described as context-window-optimized — it generates a Foundry proof of concept for a finding already under discussion, which is the natural next step once an audit skill surfaces a candidate flaw. blockchain-forensics traces stolen funds and attributes attacker wallets using only public on-chain data, and doubles as a deployer-history and privileged-role validation tool during audits, while safe-hunt sweeps DeFi protocol Safe multisig wallets for governance misconfigurations, scoring each against a finding-pattern library and emitting an audit-ready ranked report.

The llms folder is where .context feels most current, because it treats LLM applications, agents and the protocols around them as a testable surface. prompt-injection-audit composes objective-by-technique payloads and delivers them through the channels an agent actually reads — pages, tool responses, files, tickets, RAG — proving impact with an out-of-band callback rather than an LLM judge where one is not needed. That callback-first verification stance is a genuinely sound design: injection impact claims are notoriously easy to fabricate, and an OOB interaction is falsifiable. mcp-server-pentest targets MCP servers for authentication bypass, confused-deputy SSRF and tool-argument injection, working black-box from the server URL and deeper with repo or host access. llm-fuzz-tools runs multiple LLM red-team scanners against one target, normalizes their outputs to a common schema, deduplicates across them and reports honest coverage instead of a summed probe count — a quiet rejection of the metric inflation common in that space.

The hunter-utils category is the workflow backbone, and several entries deserve attention for how they encode operational discipline. sandboxed-audit-runner wraps the agent session in the Anthropic Sandbox Runtime before auditing untrusted code, explicitly to protect the host from prompt injection embedded in the codebase being reviewed — a threat the tool itself takes seriously elsewhere. audit-scope generates a scope document from GitHub repo URLs and API descriptions with an NSLOC count, focus areas and day estimates, which is the kind of pre-engagement artifact that keeps an assessment inside its authorized boundaries. pre-bounty maps assets, mines bug history, extracts scope gotchas and ranks targets by opportunity with a Sankey diagram, while hackerone-report drives a submission end to end — dedup pre-flight, writeup, PoC packaging, form-fill — but hands the irreversible login and Submit steps back to the human. That deliberate human-in-the-loop on irreversible actions is a strong safety design worth studying on its own.

Evidence quality gets its own tooling. evidence-video turns a bug reproduction into a short walkthrough where every scene is a real capture from browser, proxy or terminal, hashed into a tamper-evident manifest so a reviewer can re-run verification and the chain either holds or breaks; a Python generator refuses to emit a scene without a real frame, redacts secrets from request-response pairs, and ends on impact and blast radius. Paired with nuclei-suggest, which browses nuclei-templates passively, tiers a scoped template set by blast radius, and only sends traffic on execution against an authorized target with a confirmed ceiling, the pattern is consistent: the library repeatedly separates passive selection from active execution and keeps the human in charge of the boundary crossing.

The defensive side is not an afterthought. skills/defensive/ carries endpoint-threat-hunt for live hunting across process, file, network, persistence and registry categories using native OS tools on macOS, Linux and Windows, with a structured report that explicitly states its coverage gaps — an honesty feature more tools should copy. dylib-hijack-scan scans macOS applications for weak-dylib and rpath-order hijack susceptibility, scored by whether library validation actually blocks the attack, and parse-security acts as a last gate before untrusted instruction content is ingested, screening fetched skills, goals and workflows for prompt injection on the explicit assumption their author wrote them to defeat exactly that review. Notably, the repo applies its own defensive thinking to itself: every third-party skill you install is treated as hostile input until screened.

For an authorized professional, .context is best understood as a methodology compendium that happens to execute. It is not a scanner, it is not a framework with a daemon — it is structured knowledge that makes a capable agent behave like a trained auditor, with thresholds, scoping, sandboxing and human checkpoints embedded in the workflows. The main caveats are operational: several skills direct real traffic at real targets, so the authorization ceiling must be established before invocation, and the skills themselves are supply-chain surface — the parse-security skill exists precisely because the maintainers know a poisoned SKILL.md is the obvious attack on this model. Pull it, read a few SKILL.md files raw before you run the wizard, and you will learn as much about agent-skill architecture as about the auditing techniques it encodes.

Official project repository for forefy/.context.
Download Tool

Educational analysis for authorized security professionals. Use only in controlled, authorized environments.

Sponsored
Share articleFacebookXLinkedIn

Continue exploring

Browse all articles →

0 comentários:

Post a Comment

Note: Only a member of this blog may post a comment.