> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

AntiFox: The AI Pentesting Platform That Generates Client Reports, Not Just Findings

[ View on GitHub ]

AntiFox: The AI Pentesting Platform That Generates Client Reports, Not Just Findings

Hook

Most pentesting tools stop at finding vulnerabilities. AntiFox keeps going: it captures every HTTP packet during exploitation, binds them to reproduction steps, and generates client-ready Word documents with CVSS tables and step-by-step proof chains—all from a single Go binary.

Context

The pentesting workflow has a dirty secret: the exploitation is often the easy part. Security consultants spend 60-70% of project time not finding vulnerabilities, but documenting them for clients who need business-digestible reports with reproducible proof chains. Tools like Metasploit and Burp Suite excel at discovery and exploitation, but they dump raw technical output—JSON blobs, HTTP logs, terminal scrollback—that requires days of manual reconstruction into PowerPoint decks or Word documents.

This gap between 'vulnerability found' and 'deliverable shipped' is where most automation dies. AntiFox, a Go-based autonomous pentesting platform forked from ARTEX, attacks this last-mile problem with an evidence-first architecture. Instead of treating report generation as an afterthought, it persists exploitation steps as structured database records during execution, precision-links them to MITM-captured packets via timestamp windows, and pipes everything through LLM narrative generation into python-docx templates. The result: push-button .docx reports in English or Chinese with TOCs, vulnerability tables, and forensic reproduction chains. It's pentesting tooling designed for consultancies who bill by deliverables, not researchers who publish CVEs.

Technical Insight

Execution

PostgreSQL Storage

Core Engine (Event-Driven)

Frontend

task config

read state

read state

emit intents

claim & execute

record steps

write facts/vulns

link traffic

anchor points

mutations wake

check rules

manual override

vuln lineage

reproduction steps

inject context

inject context

Next.js UI

go:embed static

Planner Agent

reads graphs → emits intents

Worker Agents

claim intents → execute skills

HITL Interceptor

pause & override

Global Asset Graph

hosts/services/creds

Per-Task Exploration Graphs

target→intent→fact→vuln chains

Traffic Packets

timestamp + sequence

Dual RAG Vectors

global + per-task

Skill System

embedded Go + MCP

Structured Execution Steps

request/response/verification

Report Pipeline

LLM narrative → python-docx

System architecture — auto-generated

AntiFox's core innovation is a dual-graph architecture that separates cross-task ground truth from per-task exploration state. The global asset graph stores discovered hosts, services, and credentials as shared facts available to all pentest tasks. Per-task exploration graphs track target → intent → fact → vulnerability lineage chains specific to each engagement, connected to the global graph via anchor points. This design prevents exploration pollution—Task A's speculative probes don't clutter Task B's asset inventory—while enabling cross-task enrichment when a credential from Task A unlocks assets in Task B.

The engine orchestrates multi-agent collaboration through an event-driven state machine. A single planner agent reads graph state and emits intents (high-level goals like 'enumerate SMB shares on 10.0.1.5'). Worker agents claim unclaimed intents, execute skills to fulfill them, and write results back to graphs as facts or vulnerabilities. Graph mutations wake the planner for the next cycle. This single-writer pattern eliminates intent conflicts—only the planner emits, preventing N workers from generating redundant or contradictory goals.

Here's how the skill system bridges planning and execution. Skills are either embedded Go functions or MCP (Model Context Protocol) services. During execution, workers record every step as structured data:

// Simplified skill execution flow
type ExecutionStep struct {
    TaskID       uuid.UUID
    SkillName    string
    StartTime    time.Time
    EndTime      time.Time
    Request      *CapturedPacket  // FK to MITM table
    Response     *CapturedPacket
    Verification string           // LLM-generated check
    Success      bool
}

func (w *Worker) ExecuteSkill(intent Intent) {
    step := &ExecutionStep{
        SkillName: intent.RequiredSkill,
        StartTime: time.Now(),
    }
    
    // Skill runs, proxy captures packets
    result := w.skillRegistry.Run(intent.Params)
    
    // Link packets by timestamp window
    step.Request = w.proxyLog.GetByWindow(
        step.StartTime, 
        step.StartTime.Add(result.Duration),
    )
    step.EndTime = time.Now()
    step.Verification = w.llm.GenerateVerification(result)
    
    db.Insert(step)  // Persisted, not ephemeral
}

This evidence-first approach means vulnerability proof chains are constructed during exploitation, not reconstructed afterward. When an SQL injection succeeds, AntiFox auto-links the exact HTTP POST with ' OR 1=1-- to that execution step. The PostgreSQL schema stores both structured metadata (task, skill, timestamp) and full raw packets, queryable via syntax-highlighted UI or exported to reports.

Report generation leverages this structured data pipeline. The Go backend queries execution steps for a completed task, groups them by vulnerability, and feeds chains to an LLM prompt that generates narrative descriptions in the client's language (the codebase includes prompts for simplified/traditional Chinese and English). Python-docx templates transform LLM output plus packet screenshots into .docx with:

  • Cover pages with engagement metadata
  • Executive summaries (LLM-generated risk aggregation)
  • CVSS-scored vulnerability tables
  • Step-by-step reproduction sections with syntax-highlighted requests
  • Remediation recommendations (RAG-injected from knowledge base)

The entire pipeline runs server-side—no 'export JSON and paste into Word' manual steps. For consultancies running dozens of engagements monthly, this automation compresses report turnaround from days to hours.

The MITM proxy integration solves a persistent pentesting pain point: lost traffic context. Most tools require you to remember which Burp tab held the successful payload or manually correlate terminal output with proxy history. AntiFox's proxy writes every request/response to PostgreSQL with microsecond timestamps, then execution steps reference packets by time windows and sequence order. Click a vulnerability in the UI, and you get the raw HTTP that triggered it—no hunting through scrollback or attempting to replay requests from memory. This 'open-to-understand' workflow mirrors what clients need: clear cause-and-effect chains, not 'trust me, it's exploitable.'

The dual-layer RAG system injects domain knowledge at global and per-task scope. Global RAG embeds CVE databases, exploit techniques, and remediation guides into pgvector, seeding planner/worker prompts with relevant context. Per-task RAG indexes engagement-specific documents (SOWs, architecture diagrams) so agents tailor exploitation to client environments. A financial services pentest might prioritize PCI-DSS compliance checks; a healthcare engagement targets HIPAA violations—same engine, context-adapted behavior.

Gotcha

AntiFox's LLM dependency is both its superpower and its Achilles' heel. The planner and workers rely entirely on Claude or GPT-4 API calls for decision-making, intent generation, and narrative writing. If your API quota expires mid-engagement, autonomous progression halts—there's no fallback to deterministic Metasploit-style module execution. Worse, model regressions (when OpenAI updates GPT-4 and changes behavior) can degrade agent quality overnight. One user reported the planner getting 'stuck in loops' after a Claude API update, repeatedly emitting the same failed intent. Prompt engineering becomes operational burden: you're not just configuring payloads, you're debugging why the LLM decided SQL injection wasn't worth trying.

The architecture also serializes per-task exploration. While workers parallelize intent execution within a task, there's no evidence the system runs multiple pentest tasks concurrently against different targets. For red teams needing to scan 500 web apps in parallel (a use case Nuclei or Burp Suite Enterprise handles easily), AntiFox's depth-first autonomous approach becomes a throughput bottleneck. The dual-graph design is elegant for deep exploitation of complex environments, but horizontal scaling across massive attack surfaces isn't the design goal. Additionally, the MITM proxy's full-packet capture generates substantial PostgreSQL I/O—a week-long engagement could produce gigabytes of traffic data, and there's no mention of log rotation, compression, or clustering for high-availability deployments.

Verdict

Use AntiFox if you're a security consultancy or red team whose business model depends on delivering polished vulnerability reports to non-technical stakeholders, and you're willing to trade deterministic control for autonomous breadth. The evidence-first architecture and push-button .docx generation justify the LLM costs when your alternative is paying senior pentesters $200/hour to write Word documents. It shines for complex internal network pentests where deep exploitation chains (initial access → lateral movement → privilege escalation) need forensic documentation. Skip it if you need high-throughput external scanning (Nuclei is 10x faster), covert operations requiring traffic fingerprint evasion (Cobalt Strike has actual OpSec), or deterministic workflows where LLM unpredictability is unacceptable (critical infrastructure assessments). Also skip if you can't run AGPL software in your jurisdiction, lack Go expertise to audit the codebase for supply chain risks, or need multi-task horizontal scaling for large attack surfaces. The Docker deployment and PostgreSQL storage make it production-ready for small-to-medium teams, but enterprise pentesting farms will hit database bottlenecks without custom clustering work.