DITING: The LLM-Orchestrated Pentest Platform That Chose Workflows Over Autonomy
Hook
Most LLM security tools promise autonomous hacking. DITING took the opposite bet: it added manual approval gates to every high-risk action, turning AI from executor into advisor.
Context
Penetration testing has a project management problem disguised as a technical one. The tools work—Nmap finds hosts, Burp discovers vulnerabilities, Metasploit exploits them—but coordinating these tools across multi-week engagements while maintaining evidence chains for client reports remains a spreadsheet nightmare. Traditional platforms like Faraday solved collaboration but require manual task planning. You decide what to scan, when to escalate, which findings matter. The LLM revolution promised to automate this decision-making, spawning tools that autonomously chain exploits and pivot through networks.
DITING rejected that vision. Built on the ARTEX codebase but forked toward workflow management, it positions LLMs not as autonomous agents but as task advisors within human-controlled workflows. The architecture—Go backend, Next.js frontend, PostgreSQL persistence—supports a pentest management system where operators maintain authority over every consequential action while an LLM planner suggests next steps, decomposes reconnaissance into subtasks, and maps traffic to vulnerable assets. This design reflects pragmatic constraints: legal authorization limits, client-specific rules of engagement, and the operational reality that no security team will let an AI exploit production systems without oversight. The result is a platform that looks like autonomous pentesting but operates like intelligent workflow automation.
Technical Insight
DITING's core innovation is its traffic-to-asset binding model, which creates bidirectional traceability between HTTP requests and discovered infrastructure. When the integrated proxy intercepts traffic during reconnaissance, it doesn't just log requests—it associates each request/response pair with specific asset records in PostgreSQL. This means every vulnerability finding links directly back to the raw HTTP evidence that triggered it, creating an audit trail from initial discovery through exploitation.
The database schema reveals this design. Assets store discovered hosts with metadata (IP, hostname, services), while a separate traffic_captures table stores full request/response pairs with foreign keys back to asset_id. When the LLM planner suggests testing an endpoint for SQL injection, the system automatically retrieves all captured traffic for that asset, feeds relevant requests to the LLM as context, and stores the resulting exploit attempts with references to both the original discovery traffic and the testing traffic. This creates queryable evidence chains:
-- Trace a vulnerability from finding back through all related traffic
SELECT
f.title AS vulnerability,
f.severity,
a.hostname AS target,
tc.request_method,
tc.request_path,
tc.captured_at
FROM findings f
JOIN assets a ON f.asset_id = a.id
JOIN traffic_captures tc ON tc.asset_id = a.id
WHERE f.id = $1
ORDER BY tc.captured_at;
The LLM orchestration layer operates through a plugin architecture where security tools expose standardized interfaces. Each tool (Nmap, Nuclei, SQLMap) runs as a plugin that accepts JSON task specifications and returns structured results. The LLM planner doesn't execute tools directly—it generates task specifications that route through an approval queue. For reconnaissance, this might auto-approve; for exploitation, it pauses for manual confirmation.
Here's how task decomposition works in practice. An operator creates a high-level goal: "Test web application at example.com for common vulnerabilities." The LLM planner (configured with GPT-4 or Claude via API) breaks this into subtasks:
{
"goal": "Test example.com for vulnerabilities",
"subtasks": [
{
"id": "recon-1",
"type": "reconnaissance",
"tool": "nmap",
"params": {
"target": "example.com",
"ports": "80,443,8080,8443",
"scripts": "http-enum,ssl-cert"
},
"auto_approve": true
},
{
"id": "vuln-1",
"type": "vulnerability_scan",
"tool": "nuclei",
"params": {
"target": "{{recon-1.web_urls}}",
"templates": "cves,vulnerabilities"
},
"depends_on": ["recon-1"],
"auto_approve": true
},
{
"id": "exploit-1",
"type": "exploitation",
"tool": "sqlmap",
"params": {
"url": "{{vuln-1.injectable_params}}",
"risk": 1,
"level": 1
},
"depends_on": ["vuln-1"],
"auto_approve": false,
"requires_manual_approval": true
}
]
}
Notice the auto_approve flags. Reconnaissance and vulnerability scanning proceed automatically, but exploitation tasks halt until an operator reviews and approves. This is the workflow-over-autonomy design philosophy made concrete. The LLM plans the work, but humans authorize destructive actions.
The approval mechanism integrates with the frontend through WebSocket connections. When a task requires approval, the backend pushes a notification to connected operators, displays the full task specification with LLM reasoning, and shows all related traffic captures and asset context. Approval becomes an informed decision, not a blind gate. Operators see exactly what the LLM wants to do, why it suggested that action, and what evidence led to the recommendation.
Credential management uses encrypted PostgreSQL columns with per-installation master keys. API credentials for LLM providers, target system credentials discovered during testing, and client API keys all encrypt at rest using AES-256. The implementation uses Go's crypto/aes with key derivation from a master secret stored in environment variables:
func EncryptCredential(plaintext string) (string, error) {
key := deriveKey(os.Getenv("MASTER_SECRET"))
block, err := aes.NewCipher(key)
if err != nil {
return "", err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return "", err
}
ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
return base64.StdEncoding.EncodeToString(ciphertext), nil
}
This approach supports the multi-operator deployment scenario where teams share a central DITING instance, each with different LLM API keys and target credentials, but all accessing the same project database.
The Next.js frontend exports to static files (no server-side rendering), which enables deployment behind corporate proxies and in air-gapped environments common in security work. API calls use a REST client with JWT authentication, and the UI maintains operation state entirely client-side between API requests. This creates deployment flexibility but sacrifices real-time features like live log streaming—operators must poll for task updates rather than receiving push notifications via SSR.
Gotcha
DITING ships with no LLM model, no default API configurations, and blank deployment templates. You're responsible for OpenAI or Anthropic API access, prompt engineering for your specific security tools, and configuring every plugin integration from scratch. The documentation assumes familiarity with pentest methodologies and provides minimal guidance on LLM prompt design. Expect significant setup time before conducting actual assessments—this isn't a download-and-scan tool.
The AGPL-3.0 license from the ARTEX fork creates commercial deployment constraints that limit enterprise adoption. Any modifications or internal deployments that expose functionality over a network require open-sourcing your changes. Security teams building proprietary workflows or SaaS providers wanting to offer managed pentesting cannot use DITING without GPL compliance, which typically means choosing a different platform. The Chinese-first UI and documentation also create localization friction for non-Chinese operators, with incomplete English translations and regulatory framing specific to Chinese compliance requirements.
Verdict
Use if: You manage authorized penetration tests for clients requiring detailed evidence trails, need workflow coordination for small security teams tired of spreadsheet-based project tracking, want LLM suggestions for next steps without surrendering control over destructive actions, and operate in compliance-heavy environments where proving every finding came from authorized scope matters more than speed. The traffic-to-asset binding and approval workflows genuinely solve pentest management problems. Skip if: You want actual autonomous security testing (build on Nuclei + LangChain instead), need commercial deployment without GPL restrictions (try Faraday or Metasploit Pro), operate primarily in English without time for localization, or require production-grade multi-user scalability (the single-container architecture won't handle it). DITING chose pragmatic workflow management over AI hype, which makes it valuable for specific use cases but misaligned with autonomous agent expectations.