Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/renweimeng/vlun-agent-x
Analisi StaticaAnalisi Dinamica (Sandboxing)Analisi delle VulnerabilitàAnalisi del CodiceMachine LearningPaper e RicercaSicurezza dell'IA
GitHubrenweimeng/vlun-agent-x

Vlun-Agent-X

VulnAgent-X: Un framework agentico a strati per il rilevamento di vulnerabilità a livello di repository

Vedi Repository
176 mesi faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

中文 English

VulnAgent-X Prototipo di Ricerca

VulnAgent-X è un prototipo di rilevamento di vulnerabilità/difetti multi-agente orientato alla riproduzione di paper di ricerca. Accetta in input un repository locale o un diff e produce in output findings strutturati, catena di prove, risultati di localizzazione, confidenza e log degli esperimenti.

Funzionalità principali

  • Modalità di input: repo path o unified diff
  • Flusso di lavoro: screening -> context expansion -> scheduler -> router -> experts -> sceptic -> verification(stub) -> evidence fusion
  • Campi di output:
    • issue_type
  • location(file + line range)
  • evidence_summary
  • confidence
  • severity
  • optional_cwe
  • fix_hint
  • evidence_chain
  • counter_evidence
  • Interfacce: CLI + FastAPI
  • Esperimenti riproducibili: pytest / mypy / ruff + supporto all'esecuzione con Docker
  • Panoramica del flusso di lavoro

    1. screening: screening rapido delle aree sospette (regole + segnali dai metadati)
    2. context_expansion: recupero del "contesto minimo sufficiente" (estrazione di finestre basate sulle posizioni sospette)
    3. scheduler: strategie di escalation basate su confidenza e rischio (early_exit / expert_review / verification)
    4. router_agent: seleziona l'Agent esperto per ogni area sospetta
    5. semantic/security/logic: forniscono affermazioni strutturate e prove da diverse prospettive
    6. sceptic_agent: genera controprove e segnali di penalizzazione
    7. verification: verifica dinamica opzionale (attualmente implementazione segnaposto sicura)
    8. evidence_fusion: fusione unificata delle prove e output dei findings finali

    Guida all'installazione e all'esecuzione

    1) Preparazione dell'ambiente

    Requisiti: Python 3.11+ (attualmente funziona anche su versioni più recenti)

    root@kitploit:~
    cd /Users/xiaolu/Documents/Python_code/vulnAgentX
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install -e '.[dev]'
    

    2) Utilizzo della CLI

    Analizza un intero repository:

    root@kitploit:~
    .venv/bin/vulnagentx analyze --repo /path/to/repo --output json
    

    Analizza un file di diff:

    root@kitploit:~
    .venv/bin/vulnagentx analyze --diff-file /path/to/patch.diff --output json
    

    Output sintetico:

    root@kitploit:~
    .venv/bin/vulnagentx analyze --repo /path/to/repo --output summary
    

    3) Utilizzo dell'API

    Avvia il servizio:

    root@kitploit:~
    .venv/bin/uvicorn vulnagentx.app.api:app --reload
    

    Health check:

    root@kitploit:~
    curl http://127.0.0.1:8000/health
    

    Avvia un'analisi:

    root@kitploit:~
    curl -X POST http://127.0.0.1:8000/analyze \
      -H "Content-Type: application/json" \
      -d '{"repo_path":"/path/to/repo"}'
    

    4) Esecuzione con Docker

    root@kitploit:~
    docker compose -f docker/docker-compose.yml up --build
    

    5) Controllo di qualità e test

    root@kitploit:~
    .venv/bin/ruff check src tests
    .venv/bin/mypy src
    .venv/bin/pytest
    

    Esempio di output

    root@kitploit:~
    {
      "run_id": "...",
      "findings": [
        {
          "issue_type": "command_injection",
          "location": {"file_path": "app.py", "start_line": 42, "end_line": 42},
          "evidence_summary": "Command execution surface detected...",
          "confidence": 0.87,
          "severity": "critical",
          "optional_cwe": "CWE-78",
          "fix_hint": "Avoid shell command composition...",
          "source_agents": ["security_agent", "semantic_agent"],
          "evidence_chain": [],
          "counter_evidence": []
        }
      ],
      "metrics": {
        "runtime_seconds": 0.07
      },
      "logs": []
    }
    

    Descrizione dei file (file per file)

    File nella directory radice e file di progetto

    FileScopo
    .env.exampleTemplate delle variabili d'ambiente (impostazioni opzionali come il livello di log).
    pyproject.tomlBuild del progetto, dipendenze, entry point degli script, configurazione di pytest/ruff/mypy.
    README.mdREADME principale (con pulsante di cambio lingua, default cinese).
    README.zh.mdDocumentazione completa in cinese.
    README.en.mdDocumentazione completa in inglese.
    docker/DockerfileFile di build dell'immagine container del servizio API.
    docker/docker-compose.ymlAvvio locale dei servizi containerizzati con un comando.
    rules/semgrep/vulnagentx-rules.ymlSet di regole Semgrep integrato (command injection/SQL injection/deserializzazione/API C non sicure).
    scripts/run_experiment.pyScript per l'esecuzione di esperimenti batch sui dataset; produce previsioni in JSONL.
    scripts/evaluate.pyLegge gli output degli esperimenti e calcola le metriche di rilevamento, localizzazione ed efficienza.
    scripts/run_ablation.pyScript per gli esperimenti di ablazione (no_semgrep/no_treesitter/no_sceptic/no_verification).

    Codice sorgente principale (src/vulnagentx)

    FileScopo
    src/vulnagentx/__init__.pyDefinizione della versione del pacchetto e delle esportazioni.
    src/vulnagentx/app/__init__.pyInizializzazione del sottopacchetto app.
    src/vulnagentx/app/cli.pyEntry point CLI (vulnagentx analyze).
    src/vulnagentx/app/api.pyEntry point del servizio FastAPI (/health, /analyze).
    src/vulnagentx/app/schemas.pySchema Pydantic per richieste/risposte API.
    src/vulnagentx/core/__init__.pyInizializzazione del sottopacchetto core.
    src/vulnagentx/core/state.pyModello dello stato globale: regioni, prove, output degli Agent, Finding, log, metriche.
    src/vulnagentx/core/screening.pyScreening rapido della prima fase, estrazione delle aree sospette.
    src/vulnagentx/core/context_expansion.pyEspansione del contesto: estrazione delle finestre di codice minime in base alla localizzazione.
    src/vulnagentx/core/scheduler.pyStrategie di escalation sensibili alla confidenza (early_exit/expert_review/verification).
    src/vulnagentx/core/verification.pyModulo di verifica dinamica opzionale (attualmente versione segnaposto sicura).
    src/vulnagentx/core/evidence_fusion.pyFusione delle prove dei molteplici Agent, output dei findings finali.
    src/vulnagentx/core/workflow.pyEntry point di orchestrazione end-to-end VulnAgentWorkflow.
    src/vulnagentx/agents/__init__.pyAggregazione delle esportazioni degli Agent.
    src/vulnagentx/agents/base.pyClasse base astratta degli Agent e utility per l'acquisizione del contesto.
    src/vulnagentx/agents/router_agent.pyAgent di routing: assegna un Agent esperto a ogni area sospetta.

    File di test (tests)

    FileScopo
    tests/test_agents.pyUnit test: output strutturati dei singoli Agent e logica delle controprove.
    tests/test_end_to_end.pyTest end-to-end: flusso principale dal repository in input ai findings finali.
    tests/test_research_modules.pyTest dei moduli aggiunti: costruzione del grafo Tree-sitter, catena di esecuzione di verification, metriche di valutazione.

    Moduli avanzati implementati in questa versione

    • Adapter LLM reali: OpenAI + Ollama locale + commutazione automatica tramite factory
    • Tree-sitter AST e grafo del codice reali: analisi delle relazioni tra funzioni/import/chiamate, con supporto all'espansione del contesto tramite file vicini
    • Set di regole Semgrep reale: file di regole integrato e collegato alla fase di screening
    • Catena di esecuzione in sandbox per verification: pianificazione dei compiti, esecuzione limitata, controllo del timeout e scrittura strutturata dei risultati
    • Valutazione sui dataset e ablazione: caricatori di dati, moduli di metriche, script per esperimenti e ablazione
    Scarica lo strumento
    src/vulnagentx/agents/semantic_agent.pyAgent semantico: rischi a livello semantico (es. puntatori nulli, deserializzazione, eccezioni inghiottite).
    src/vulnagentx/agents/security_agent.pyAgent di sicurezza: regole per vulnerabilità di sicurezza (command injection, SQL injection, accessi fuori dai limiti, ecc.).
    src/vulnagentx/agents/logic_bug_agent.pyAgent logico: difetti di logica di business/flusso di controllo (condizioni limite, divisione per zero, autorizzazioni mancanti, ecc.).
    src/vulnagentx/agents/sceptic_agent.pyAgent scettico: genera controprove, penalizzazioni per conflitti e riduzione della confidenza.
    src/vulnagentx/adapters/__init__.pyInizializzazione del sottopacchetto degli adapter.
    src/vulnagentx/adapters/sandbox_adapter.pyEsecutore sandbox per sottoprocessi limitato (timeout, niente shell) utilizzato per verification.
    src/vulnagentx/adapters/semgrep_adapter.pyAdapter per la CLI di Semgrep (attivabile opzionalmente).
    src/vulnagentx/adapters/treesitter_adapter.pyAdapter Tree-sitter reale (analizza l'AST e le relazioni di chiamata/import quando disponibile; in caso contrario effettua un fallback).
    src/vulnagentx/adapters/llm/__init__.pyAggregazione delle esportazioni degli adapter LLM.
    src/vulnagentx/adapters/llm/base.pyInterfaccia protocollo dell'adapter LLM.
    src/vulnagentx/adapters/llm/mock_adapter.pyMock LLM testabile offline.
    src/vulnagentx/adapters/llm/openai_adapter.pyAdapter per l'SDK ufficiale OpenAI.
    src/vulnagentx/adapters/llm/local_adapter.pyAdapter per modelli locali (Ollama HTTP API).
    src/vulnagentx/adapters/llm/factory.pySeleziona automaticamente l'adapter LLM in base alla configurazione, con fallback al Mock.
    src/vulnagentx/retrieval/repo_graph.pyIndice del grafo del codice e recupero dei file vicini (basato sulla sovrapposizione dei simboli AST).
    src/vulnagentx/datasets/base.pyStruttura generica dei campioni del dataset e lettura di file JSONL/CSV.
    src/vulnagentx/datasets/devign.pyEntry point per il caricamento dei dati Devign.
    src/vulnagentx/datasets/bigvul.pyEntry point per il caricamento dei dati Big-Vul.
    src/vulnagentx/datasets/primevul.pyEntry point per il caricamento dei dati PrimeVul.
    src/vulnagentx/datasets/jit.pyEntry point per il caricamento dei dati JIT.
    src/vulnagentx/eval/detection_metrics.pyMetriche di rilevamento (Precision/Recall/F1/Accuracy).
    src/vulnagentx/eval/localization_metrics.pyMetriche di localizzazione (Top-1/Top-3/MRR).
    src/vulnagentx/eval/efficiency_metrics.pyMetriche di efficienza (tempo medio, P95, findings medi).
    src/vulnagentx/eval/ablations.pyLogica di esecuzione degli esperimenti di ablazione.
    src/vulnagentx/utils/config.pyCentro di configurazione del flusso di lavoro (opzioni abilitabili via env/CLI/API).