akha-security/akcaScanner DAST orientato alle evidenze in Go che esegue la scansione di app web e API, quindi esegue controlli adattivi di SQLi, XSS, RCE, SSRF e autenticazione con prova riproducibile.
Scanner Avanzato di Sicurezza Web
Scopri endpoint. Testa applicazioni web. Ispeziona le prove.
Installazione · Utilizzo · Flusso di lavoro · Profili · Copertura · Report · Supporto · Funzionalità · Changelog
AKCA è uno scanner DAST (Dynamic Application Security Testing) open-source orientato alle prove, scritto in Go. Combina crawling HTTP e assistito da browser, analisi JavaScript, importazione di API, test attivi adattivi, ispezione passiva e prove riproducibili in un unico flusso di lavoro da riga di comando.
Molti scanner eseguono il crawling di un'applicazione e poi inviano un ampio set di payload a ogni endpoint scoperto. Questa strategia può generare traffico non necessario, attivare sistemi difensivi e produrre segnali deboli che richiedono una sostanziale analisi manuale. AKCA adotta un approccio più contestuale: prima apprende informazioni sul target, modella la superficie di attacco scoperta, e poi seleziona i test in base allo stack tecnologico, ai parametri, allo stato di autenticazione, al comportamento del WAF e alle capacità di verifica disponibili.
AKCA è progettato per:
L'obiettivo non è esaurire o sopraffare il target. È trovare debolezze reali con richieste deliberate e prove utili.
AKCA non rivendica la parità di funzionalità o rilevamento con piattaforme commerciali mature come Acunetix, Invicti/Netsparker o Burp Suite Professional. Quei prodotti sono costruiti da team esperti nel corso di molti anni. AKCA è mantenuto in modo indipendente da un singolo sviluppatore nel tempo personale disponibile, ispirato a strumenti di sicurezza consolidati e plasmato da idee originali e feedback della comunità. La priorità attuale è uno scanner semplice, utile e trasparente. Un'interfaccia grafica è prevista quando il motore sarà sufficientemente stabile e affidabile.
Sessione di scansione AKCA v0.2.4 con stato del motore in tempo reale, telemetria delle risorse e risultati confermati.
Richiede Go 1.25 o versione successiva.```bash go install github.com/akha-security/akca/engine/cmd/akca@latest akca --version
<details>
<summary>Comando non trovato? Configura il tuo PATH.</summary>
Per l'installazione predefinita di Go, aggiungi la directory dei binari di Go al `PATH` del tuo terminale corrente.
**Linux / macOS**```bash
export PATH="$(go env GOPATH)/bin:$PATH"
Aggiungi quella riga alla configurazione della tua shell per mantenerla tra le sessioni.
Windows PowerShell```powershell $env:Path += ";$(go env GOPATH)\bin"
Per le sessioni future, aggiungi la stessa directory alla variabile d'ambiente `Path` del tuo utente. Se hai configurato `GOBIN`, usa invece quella directory.
</details>
### Binari precompilati
Scarica la tua build da [GitHub Releases](https://github.com/akha-security/akca/releases/latest). Le release includono `SHA256SUMS.txt` per la verifica del checksum.
| Piattaforma | Architettura | Asset |
| --- | --- | --- |
| Linux | x64 / ARM64 | `akca-linux-amd64` / `akca-linux-arm64` |
| macOS | Intel / Apple Silicon | `akca-darwin-amd64` / `akca-darwin-arm64` |
| Windows | x64 | `akca-windows-amd64.exe` |
Su Linux o macOS, rendi eseguibile il file scaricato. Per Linux x64:```bash
chmod +x akca-linux-amd64
./akca-linux-amd64 --help
Su Windows, rinomina il download in akca.exe ed esegui .\akca.exe --help in PowerShell. Gli esempi seguenti presuppongono che akca sia disponibile nel tuo PATH.
I controlli basati sul browser richiedono Chrome, Chromium o Edge.
Usa AKCA solo su sistemi di tua proprietà o per i quali hai il permesso di eseguire test. Sostituisci l'URL di esempio con il tuo target autorizzato.
akca -u https://example.com
Il profilo predefinito è `full`. Per salvare un report HTML:```bash
akca -u https://example.com -f html -o report.html
Esegui controlli di SQL injection, XSS e injection lato server, inclusa SSTI:```bash akca -u https://example.com -m sql,xss,rce
Esegui controlli passivi:```bash
akca -u https://example.com -m passive
Le scansioni passive inviano comunque richieste per il rilevamento e l'ispezione.
Fornire un cookie di sessione:```bash akca -u https://example.com -c "session=YOUR_SESSION_COOKIE"
O un header di autorizzazione:```bash
akca -u https://example.com -H "Authorization: Bearer YOUR_TOKEN"
Alcuni controlli di autorizzazione richiedono identità aggiuntive o configurazione dello stato oltre a una singola sessione.
akca -u https://api.example.com --api-spec ./openapi.yaml -m api
Discovery supporta input OpenAPI/Swagger, RAML, Postman, HAR, GraphQL, WSDL, protobuf e AsyncAPI, inclusi i bundle ZIP supportati. La copertura dei test dipende dal protocollo e dall'operazione importati.
### Ispeziona il traffico attraverso un proxy```bash
akca -u https://example.com -p http://127.0.0.1:8080
Esegui akca --help per tutte le opzioni disponibili.
Usa akca -h per un aiuto conciso di uso quotidiano, oppure akca --help per il riferimento completo delle opzioni. I target di scansione devono essere forniti esplicitamente con -u o --url.
Seleziona un profilo con -m, oppure combinane diversi con le virgole.
| Profilo | Controlli |
|---|---|
full | Tutti i moduli attivi e passivi abilitati; il predefinito |
sql | SQL e NoSQL injection |
xss | XSS reflected, stored, DOM e blind; controlli lato client correlati |
rce | Command injection, SSTI, deserializzazione e controlli correlati |
api | Esposizione API, BOLA/IDOR, BFLA, mass assignment e controlli sui token |
graphql | Controlli su schema e operazioni GraphQL |
ssrf | SSRF, XXE e controlli out-of-band correlati |
auth | Autenticazione, autorizzazione, CSRF e controlli su cookie/header |
passive | Metadati, TLS, security header, segreti e analisi dei componenti |
fuzz | Percorsi, artefatti esposti, traversal e controlli correlati |
L'esecuzione dipende dagli endpoint scoperti, dalla configurazione, dalle capacità di verifica disponibili e dai limiti di scansione. Consulta FEATURES.md per la guida completa alle capacità.
AKCA utilizza una pipeline a fasi, così che i controlli successivi possano beneficiare delle informazioni apprese in precedenza:
La copertura è esplicita. Un target saltato, fallito, limitato dal budget o non completato viene registrato come copertura incompleta; non viene silenziosamente trattato come un risultato di sicurezza pulito.
Il seguente elenco descrive i motori di scoperta e le famiglie di test di sicurezza implementati. I singoli controlli vengono eseguiti solo quando la superficie scoperta, il profilo di scansione, la configurazione, la policy di sicurezza e i prerequisiti di verifica li rendono applicabili. Una capacità elencata non è una garanzia che ogni variante di una vulnerabilità venga rilevata.
Imposta un budget totale di richieste e una durata massima:```bash akca -u https://example.com --request-budget 5000 --time-budget 30m
Oppure calcola il budget del modulo dalle combinazioni URL/metodo scoperte:```bash
akca -u https://example.com --requests-per-target 200
AKCA distribuisce budget di modulo limitati tra moduli, URL e parametri. Le allocazioni inutilizzate vengono spostate in avanti verso il lavoro successivo. Un --request-budget positivo ha la precedenza su --requests-per-target.
| Opzione | Scopo |
|---|---|
--request-budget 5000 | Limita le richieste totali, incluse discovery, retry e redirect |
--requests-per-target 200 | Deriva il budget del modulo dalle combinazioni URL/metodo scoperte |
--crawler-budget 1000 | Limita le richieste di discovery |
--time-budget 30m | Limita la durata della scansione |
--rate-limit 5 | Limita le richieste al secondo |
--concurrency 4 | Limita i worker concorrenti |
Per impostazione predefinita, la scansione del modulo non ha quota di richieste. Le interruzioni dovute al budget vengono segnalate come copertura incompleta. I target interrotti non vengono ripresi automaticamente quando il lavoro successivo restituisce budget inutilizzato. Nessuna impostazione del budget garantisce il rilevamento di ogni vulnerabilità.
I sottodomini API/servizio collegati sono al di fuori dell'ambito target predefinito. Per includere i sottodomini collegati sotto la stessa radice:```bash akca -u https://www.example.com --include-linked-api-subdomains
### Perché una scansione completa richiede più tempo
La scansione completa predefinita di AKCA è progettata per la copertura e la qualità delle prove, non per il minor tempo di completamento possibile. Il suo tempo di esecuzione non è quindi direttamente confrontabile con strumenti che si fermano dopo un crawl HTTP superficiale o segnalano una vulnerabilità a partire da una singola differenza di risposta.
Un'esecuzione completa può richiedere più tempo perché AKCA:
- Mantiene una sessione browser per le route renderizzate lato client e ispeziona JavaScript, inclusi i chunk applicativi caricati in modo lazy.
- Riproduce i risultati promettenti con controlli prima di promuoverli a finding, riducendo i falsi positivi causati da errori generici, pagine instabili e risposte WAF.
- Esegue controlli consapevoli di identità, stato e callback quando un modulo richiede prove più solide.
- Rispetta il pacing del target, i retry, i budget di richieste e le finestre di osservazione out-of-band invece di considerare la velocità come unico parametro di successo.
La durata della scansione dipende anche dalle dimensioni dell'applicazione, dalla latenza delle risposte, dai flussi di autenticazione, dai controlli difensivi e dallo scope configurato. Per un feedback più rapido, seleziona solo i moduli pertinenti con `-m` oppure applica budget espliciti di crawl, richieste e tempo. Aumenta rate e concorrenza solo quando il target autorizzato può gestire in sicurezza il traffico aggiuntivo. Una scansione più breve non è necessariamente una scansione più completa.
## Report
Scegli un formato di output con `-f` e un percorso file con `-o`:```bash
akca -u https://example.com -f html -o report.html
Formati supportati: HTML, JSON, Markdown, CSV e SARIF. Ogni invocazione avvia una nuova scansione.
I report HTML sono autonomi e includono il logo AKCA, riepiloghi di rischio e gravità, statistiche sulle vulnerabilità, dettagli strutturati dei risultati e prove HTTP espandibili. Le schede richiesta e risposta supportano una vista combinata, l'espansione del contenuto completo e la copia. Quando un risultato conserva un valore di risposta corrispondente, AKCA lo evidenzia in giallo, aiutandoti a individuare un payload riflesso o un segreto esposto. I risultati passivi sui segreti mantengono un estratto attorno alla corrispondenza.
A seconda del modulo, i risultati includono:
I risultati di timing, le intestazioni mancanti e i callback esterni possono non avere testo di risposta da evidenziare. Il loro contesto di verifica fornisce le prove rilevanti.
Quando lo scanner ha memorizzato una transazione grezza completa, il report la preserva esattamente. Le prove più vecchie o solo strutturate vengono renderizzate in un layout HTTP convenzionale in stile Burp con una request line, intestazioni ordinate, un separatore intestazione/corpo e frasi di motivo standard delle risposte HTTP. Se il limite di cattura del trasporto ha troncato una risposta, il report lo dichiara esplicitamente; non presenta mai la porzione memorizzata come la risposta completa non disponibile.
Riproduci un risultato memorizzato:```bash akca replay --finding 42
I report mascherano le credenziali riconosciute per impostazione predefinita. Le prove grezze memorizzate vengono conservate per la riproduzione. Imposta `redact_reports` su `false` nella configurazione della scansione, oppure usa `redact=false` sull'API dei report, solo quando sono necessarie esportazioni grezze. Esamina i report prima di condividerli: il mascheramento automatico non è in grado di riconoscere ogni segreto specifico dell'applicazione.
### Configurazione di crawl e proof
Il crawler mantiene una sessione browser per tutta la durata di ciascuna fase di crawl, inclusi cookie e storage del browser. Esplora schede esplicite non-form e pannelli espandibili; non compila né invia automaticamente i form. Le richieste del browser rispettano comunque lo scope e i budget di richieste. Per le dipendenze statiche di terze parti richieste, configura gli hostname esatti separatamente:```json
{
"browser_resource_domains": ["cdn.example.com"],
"redact_reports": true
}
Questo consente solo richieste GET/HEAD di script, fogli di stile, immagini, font e media verso quegli host, rimuovendo le credenziali e le intestazioni personalizzate. Non aggiunge quegli host all'ambito di scansione attivo né consente chiamate API cross-origin. Le dipendenze del browser bloccate producono eventi di copertura mancante.
Gli URL scoperti vengono conservati anche quando non possono essere visitati. Una scansione che esaurisce il proprio budget con lavoro in coda produce una scansione parziale e un codice di uscita CLI diverso da zero. I messaggi di preflight dei moduli distinguono le policy di identità/stato mancanti dalle capacità di verifica configurate.
I controlli di rate-limit non configurati producono osservazioni, non risultati di vulnerabilità. Una prova di soglia configurata richiede anche window_seconds; se le richieste non rientrano in quella finestra, il controllo è inconcludente. SQLi non considera una risposta 400 o la sola valutazione aritmetica come prova. I nuovi errori SQL specifici del vendor nelle risposte 400/422 devono superare il percorso di replay e verifica di controllo.
Vedi CHANGELOG.md per i dettagli di rilascio.
AKCA non accetta sponsorizzazioni o donazioni personali. Contributi di codice, test, documentazione e feedback ponderato sono sempre benvenuti.
Projeye maddi olarak destek olmak istiyorsanız, bana göndermek yerine Mehmetçik Vakfı, AFAD, Türk Kızılay veya Çocuk Hizmetleri Genel Müdürlüğü aracılığıyla desteklenen güvenilir sosyal yardım çalışmalarından birine bağış yapmanızı rica ediyorum. Mümkünse bağışınızı kızım Akça Aktaş adına yapın. Bağıştan sonra X üzerinden @caneraktas_ hesabına mesaj göndermeniz beni gerçekten çok mutlu eder.
Se desideri sostenere finanziariamente il progetto, ti prego di donare a un'organizzazione benefica affidabile nel tuo paese che aiuti i bambini, le comunità colpite da disastri, i veterani o le persone in urgente necessità. Quando possibile, effettua la donazione a nome di mia figlia, Akça Aktaş. Sei invitato a condividerlo con me su X all'indirizzo @caneraktas_; sapere che questo progetto ha ispirato un atto di aiuto significherebbe molto per me.
Compila dal sorgente:```bash git clone https://github.com/akha-security/akca.git cd akca/engine go build -buildvcs=false -trimpath -o ../akca ./cmd/akca
Su Windows, usare `-o ../akca.exe` per il nome dell'eseguibile.
Eseguire i controlli dalla directory `engine`:```bash
go test ./... -count=1
go vet ./...
go run ./cmd/akca benchmark --strict
Il benchmark misura il proprio corpus osservato. Per i dettagli implementativi e i limiti di verifica, consulta la guida all'architettura e l'audit di verifica.
I contributi sono benvenuti. Leggi CONTRIBUTING.md e il Codice di Condotta prima di aprire una pull request. Segnala le vulnerabilità in AKCA tramite SECURITY.md.
Apache License 2.0 · Copyright 2026 AKHA Security contributors.