assetnote/kiterunnerStrumento di scoperta di contenuti web e API ad alta velocità che esegue brute force sulle route utilizzando dataset Swagger compilati, supportando scansione in profondità, wordlist personalizzate e scansione concorrente degli host.
Per molto tempo, la scoperta di contenuti si è concentrata sulla ricerca di file e cartelle. Sebbene questo approccio sia efficace per server web legacy che ospitano file statici o rispondono con 3xx su un percorso parziale, non è più efficace per le applicazioni web moderne, in particolare le API.
Nel corso del tempo, abbiamo visto molti sforzi investiti per rendere più veloci gli strumenti di scoperta dei contenuti, in modo da poter utilizzare wordlist più grandi, tuttavia l'arte della scoperta dei contenuti non è stata innovata.
Kiterunner è uno strumento in grado non solo di eseguire la tradizionale scoperta di contenuti a velocità fulminea, ma anche di fare brute force su percorsi/endpoint in applicazioni moderne.
Framework applicativi moderni come Flask, Rails, Express, Django e altri seguono il paradigma di definire esplicitamente route che si aspettano determinati metodi HTTP, intestazioni, parametri e valori.
Quando si utilizzano strumenti tradizionali di scoperta di contenuti, tali route vengono spesso perse e non possono essere facilmente scoperte.
Raccogliendo un dataset di specifiche Swagger e condensandolo in un nostro schema, Kiterunner può utilizzare questo dataset per fare brute force sugli endpoint API inviando il corretto metodo HTTP, intestazioni, percorso, parametri e valori per ogni richiesta che invia.
I file Swagger sono stati raccolti da diverse fonti di dati, inclusa una scansione a livello internet dei 40+ percorsi Swagger più comuni. Altre fonti includevano GitHub via BigQuery e APIs.guru.
Puoi scaricare una copia precompilata da https://github.com/assetnote/kiterunner/releases.
make build
ln -s $(pwd)/dist/kr /usr/local/bin/kr
kr kb compile routes.json routes.kite
kr scan hosts.txt -w routes.kite -x 20 -j 100 --ignore-length=1053
I dataset JSON sono disponibili di seguito:
- [routes-large.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-large.json.tar.gz) (118MB compressi, 2.6GB decompressi)
- [routes-small.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-small.json.tar.gz) (14MB compressi, 228MB decompressi)
In alternativa, è possibile scaricare i file `.kite` compilati dai link seguenti:
- [routes-large.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-large.kite.tar.gz) (40MB compressi, 183MB decompressi)
- [routes-small.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-small.kite.tar.gz) (2MB compressi, 35MB decompressi)
## AUR
Gli utenti che utilizzano una distribuzione basata su Arch possono scaricare il binario precompilato da [AUR](https://aur.archlinux.org/packages/kiterunner-bin/)
Puoi usare un "Aur Helper" come `yay` per installare kiterunner```
yay -S kiterunner-bin
kr [scan|brute] [flags]
- `<input>` può essere un file, un dominio o un URI. Lo scopriremo noi per te. Vedi [Input/Host Formatting](#inputhost-formatting) per maggiori dettagli```
# Just have a list of hosts and no wordlist
kr scan hosts.txt -A=apiroutes-210328:20000 -x 5 -j 100 --fail-status-codes 400,401,404,403,501,502,426,411
# You have your own wordlist but you want assetnote wordlists too
kr scan target.com -w routes.kite -A=apiroutes-210328:20000 -x 20 -j 1 --fail-status-codes 400,401,404,403,501,502,426,411
# Bruteforce like normal but with the first 20000 words
kr brute https://target.com/subapp/ -A=aspx-210328:20000 -x 20 -j 1
# Use a dirsearch style wordlist with %EXT%
kr brute https://target.com/subapp/ -w dirsearch.txt -x 20 -j 1 -exml,asp,aspx,ashx -D
Usage: kite scan [flags]
Flags: -A, --assetnote-wordlist strings use the wordlists from wordlist.assetnote.io. specify the type/name to use, e.g. apiroutes-210228. You can specify an additional maxlength to use only the first N values in the wordlist, e.g. apiroutes-210228;20000 will only use the first 20000 lines in that wordlist --blacklist-domain strings domains that are blacklisted for redirects. We will not follow redirects to these domains --delay duration delay to place inbetween requests to a single host --disable-precheck whether to skip host discovery --fail-status-codes ints which status codes blacklist as fail. if this is set, this will override success-status-codes --filter-api strings only scan apis matching this ksuid --force-method string whether to ignore the methods specified in the ogl file and force this method -H, --header strings headers to add to requests (default [x-forwarded-for: 127.0.0.1]) -h, --help help for scan --ignore-length strings a range of content length bytes to ignore. you can have multiple. e.g. 100-105 or 1234 or 123,34-53. This is inclusive on both ends --kitebuilder-full-scan perform a full scan without first performing a phase scan. -w, --kitebuilder-list strings ogl wordlist to use for scanning -x, --max-connection-per-host int max connections to a single host (default 3) -j, --max-parallel-hosts int max number of concurrent hosts to scan at once (default 50) --max-redirects int maximum number of redirects to follow (default 3) -d, --preflight-depth int when performing preflight checks, what directory depth do we attempt to check. 0 means that only the docroot is checked (default 1) --profile-name string name for profile output file --progress a progress bar while scanning. by default enabled only on Stderr (default true) --quarantine-threshold int if the host return N consecutive hits, we quarantine the host as wildcard. Set to 0 to disable (default 10) --success-status-codes ints which status codes whitelist as success. this is the default mode -t, --timeout duration timeout to use on all requests (default 3s) --user-agent string user agent to use for requests (default "Chrome. Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.96 Safari/537.36") --wildcard-detection can be set to false to disable wildcard redirect detection (default true)
Global Flags: --config string config file (default is $HOME/.kiterunner.yaml) -o, --output string output format. can be json,text,pretty (default "pretty") -q, --quiet quiet mode. will mute unecessarry pretty text -v, --verbose string level of logging verbosity. can be error,info,debug,trace (default "info")
flag di brute force (tutti i flag sopra +)```
-D, --dirsearch-compat this will replace %EXT% with the extensions provided. backwards compat with dirsearch because shubs loves him some dirsearch
-e, --extensions strings extensions to append while scanning
-w, --wordlist strings normal wordlist to use for scanning
When supplied with an input, kiterunner will attempt to resolve the input in the following order:
If you supply a "domain", but it exists as a file, e.g. google.com but google.com is also a txt file in the current directory,
we'll load google.com the text file, because we found it first.
Domain Parsing
Its preferred that you provide a full URI as the input, however you can provide incomplete URIs and we'll try and guess what you mean. An example list of domains you can supply are:``` one.com two.com:80 three.com:443 four.com:9447 https://five.com:9090 http://six.com:80/api
L'elenco di domini sopra si espanderà nel successivo elenco di destinazioni.```
(two targets are created for one.com, since neither port nor protocol was specified)
http://one.com (port 80 implied)
https://one.com (port 443 implied)
http://two.com (port 80 implied)
https://three.com (port 443 implied)
http://four.com:9447 (non-tls port guessed)
https://five.com:9090
http://six.com/api (port 80 implied; basepath API appended)
le regole che applichiamo sono:
Quando hai un singolo target```bash
kr scan https://target.com:8443/ -w routes.kite -A=apiroutes-210228:20000 -x 10 --ignore-length=34
kr scan target.com -w routes.kite -A=apiroutes-210228:20000 -x 10 --ignore-length=34
kr scan targets.txt -w routes.kite -A=apiroutes-210228:20000 -x 10 --ignore-length=34
## Attacco a forza bruta semplice```bash
kr brute https://target.com -A=raft-large-words -A=apiroutes-210228:20000 -x 10 -d=0 --ignore-length=34 -ejson,txt
Per quando hai una wordlist vecchio stile che contiene ancora %EXT% nella wordlist, puoi usare -D. questo sostituirà solo l'estensione dove %EXT% è presente nel percorso```bash
kr brute https://target.com -w dirsearch.txt -x 10 -d=0 --ignore-length=34 -ejson,txt -D
# Caratteristiche tecniche
## Scansione di profondità
Una caratteristica fondamentale di kiterunner è la scansione basata sulla profondità. Questo tenta di gestire il rilevamento dei wildcard dato il routing basato sui percorsi delle applicazioni virtuali. La profondità definisce quanti livelli di directory vengono eseguiti i controlli di base, Ad es.```bash
~/kiterunner $ cat wordlist.txt
/api/v1/user/create
/api/v1/user/delete
/api/v2/user/
/api/v2/admin/
/secrets/v1/
/secrets/v2/
/ avrebbe i controlli di base eseguiti per il rilevamento dei caratteri jolly/api e /secrets avrebbero i controlli di base eseguiti; e questi controlli verrebbero utilizzati rispettivamente su /api e /secrets/api/v1, /api/v2, /secrets/v1 e /secrets/v2 avrebbero tutti i controlli di base eseguiti.Per impostazione predefinita, kr scan ha una profondità di 1, poiché dall'uso interno, abbiamo spesso osservato che questa è la profondità più comune in cui si verifica il routing virtuale. kr brute ha una profondità predefinita di 0, poiché di solito non si desidera che questo controllo venga eseguito con una wordlist statica.
Naturalmente, aumentare la profondità aumenterà la precisione delle scansioni, tuttavia ciò aumenta anche il numero di richieste al target. (# of baseline checks * # of depth baseline directories). Pertanto, sconsigliamo di superare 1, e in rari casi arrivare a profondità 2.
Forniamo il download integrato e la memorizzazione nella cache delle wordlist da assetnote.io. Puoi utilizzarle con il flag -A che accetta un elenco delimitato da virgole di alias, o nomi completi.
Puoi ottenere un elenco completo di tutte le wordlist Assetnote con kr wordlist list.
Le wordlist, quando utilizzate, sono memorizzate nella cache in ~/.cache/kiterunner/wordlists. Quando utilizzate, vengono compilate da .txt -> `.kite````
+-----------------------------------+-------------------------------------------------------+----------------+---------+----------+--------+
| ALIAS | FILENAME | SOURCE | COUNT | FILESIZE | CACHED |
+-----------------------------------+-------------------------------------------------------+----------------+---------+----------+--------+
| 2m-subdomains | 2m-subdomains.txt | manual.json | 2167059 | 28.0mb | false |
| asp_lowercase | asp_lowercase.txt | manual.json | 24074 | 1.1mb | false |
| aspx_lowercase | aspx_lowercase.txt | manual.json | 80293 | 4.4mb | false |
| bak | bak.txt | manual.json | 31725 | 634.8kb | false |
| best-dns-wordlist | best-dns-wordlist.txt | manual.json | 9996122 | 139.0mb | false |
| cfm | cfm.txt | manual.json | 12100 | 260.3kb | true |
| do | do.txt | manual.json | 173152 | 4.8mb | false |
| dot_filenames | dot_filenames.txt | manual.json | 3191712 | 71.3mb | false |
| html | html.txt | manual.json | 4227526 | 107.7mb | false |
| apiroutes-201120 | httparchive_apiroutes_2020_11_20.txt | automated.json | 953011 | 45.3mb | false |
| apiroutes-210128 | httparchive_apiroutes_2021_01_28.txt | automated.json | 225456 | 6.6mb | false |
| apiroutes-210228 | httparchive_apiroutes_2021_02_28.txt | automated.json | 223544 | 6.5mb | true |
| apiroutes-210328 | httparchive_apiroutes_2021_03_28.txt | automated.json | 215114 | 6.3mb | false |
| aspx-201118 | httparchive_aspx_asp_cfm_svc_ashx_asmx_2020_11_18.txt | automated.json | 63200 | 1.7mb | false |
| aspx-210128 | httparchive_aspx_asp_cfm_svc_ashx_asmx_2021_01_28.txt | automated.json | 46286 | 928.7kb | false |
| aspx-210228 | httparchive_aspx_asp_cfm_svc_ashx_asmx_2021_02_28.txt | automated.json | 43958 | 883.3kb | false |
| aspx-210328 | httparchive_aspx_asp_cfm_svc_ashx_asmx_2021_03_28.txt | automated.json | 45928 | 926.8kb | false |
| cgi-201118 | httparchive_cgi_pl_2020_11_18.txt | automated.json | 2637 | 44.0kb | false |
Quando si utilizzano le wordlist fornite da assetnote, potrebbe non essere desiderabile utilizzare l'intera wordlist, quindi si può optare per utilizzare le prime N righe di una determinata wordlist usando la head syntax. Il formato è <wordlist_name>:<N lines> quando si specifica una wordlist.
Utilizzo```
kr scan targets.txt -A=apiroutes-210228:20000 -x 10 --ignore-length=34
kr brute targets.txt -A=aspx-210228:10 -x 10 --ignore-length=34 -easp,aspx
## Impostazioni di concorrenza/Andare veloce
Kiterunner è progettato per andare veloce su molti host. Ma solo perché puoi eseguire kiterunner con 20000 goroutine, non significa che sia una buona idea. Si verificheranno colli di bottiglia e degrado delle prestazioni con conteggi elevati di thread a causa del maggiore tempo speso per programmare le goroutine in attesa di I/O di rete e nel cambio di contesto del kernel.
Ci sono due impostazioni principali di concorrenza per kiterunner:
- `-x, --max-connection-per-host` - numero massimo di connessioni aperte che possiamo avere su un host. Gestito da 1 goroutine ciascuna. Per evitare di causare un DoS su un host, raccomandiamo di mantenere questo valore in un intervallo basso di 5-10. A seconda della latenza verso il target, questo produrrà in media tra 1 e 5 richieste al secondo per connessione (200ms - 1000ms/richiesta) verso un host.
- `-j, --max-parallel-hosts` - numero massimo di host da scansionare in un dato momento. Gestito da 1 supervisor di goroutine per ciascuno
A seconda dell'hardware da cui si esegue la scansione, il numero 'massimo' di goroutine che puoi eseguire in modo ottimale varierà. Su un AWS t3.medium, abbiamo notato un degrado delle prestazioni oltre le 2500 goroutine. Il che significa che 500 host x 5 connessioni per host (2500) produrrebbero le prestazioni di picco.
Raccomandiamo di **non** eseguire kiterunner dal tuo **macbook**. A causa di scarse ottimizzazioni del kernel per conteggi I/O elevati e chiamate di sistema Epoll su macOS, abbiamo notato prestazioni sostanzialmente inferiori (0.3-0.5x) rispetto all'esecuzione di kiterunner su un'istanza linux configurata in modo simile.
Per massimizzare le prestazioni durante la scansione di un singolo target, o di una grande superficie di attacco, raccomandiamo i seguenti suggerimenti:
- Avvia un'istanza EC2 in una regione geografica/datacenter simile ai target che stai scansionando
- Esegui alcuni benchmark iniziali contro il tuo set di target con opzioni `-x` e `-j` variabili. Raccomandiamo di avere un punto di partenza tipico di circa `-x 5 -j 100` e di incrementare `-j` man mano che l'utilizzo della CPU/le prestazioni di rete lo consentono
## Conversione tra formati di file
Kiterunner ti permette anche di convertire tra lo schema JSON, un file kite e un wordlist txt standard.
**Utilizzo**
Il formato è deciso dall'estensione del tipo di file fornita dai campi `<input>` e `<output>`. Supportiamo `txt`, `json` e `kite````bash
kr kb convert wordlist.txt wordlist.kite
kr kb convert wordlist.kite wordlist.json
kr kb convert wordlist.kite wordlist.txt
❯ go run ./cmd/kiterunner kb convert -qh
convert an input file format into the specified output file format
this will determine the conversion based on the extensions of the input and the output
we support the following filetypes: txt, json, kite
You can convert any of the following into the corresponding types
-d Debug mode will attempt to convert the schema with error handling
-v=debug Debug verbosity will print out the errors for the schema
Usage:
kite kb convert <input> <output> [flags]
Flags:
-d, --debug debug the parsing
-h, --help help for convert
Global Flags:
--config string config file (default is $HOME/.kiterunner.yaml)
-o, --output string output format. can be json,text,pretty (default "pretty")
-q, --quiet quiet mode. will mute unecessarry pretty text
-v, --verbose string level of logging verbosity. can be error,info,debug,trace (default "info")``bigquery
Quando ricevi una grande quantità di output da kiterunner, può essere difficile capire immediatamente perché una richiesta causa uno specifico codice/lunghezza della risposta. Kiterunner offre un metodo per ricostruire la richiesta dalle wordlist utilizzate, includendo tutti i parametri dell'intestazione e del corpo.
kb replay.--proxy per inoltrare le tue richieste, così da poter modificare/ripetere/intercettare la richiesta usando strumenti di terze parti se lo desideri11:25AM INF Outbound request POST /dedalo/lib/dedalo/publication/server_api/v1/json/thesaurus_parents?ar_fields=48637466&code=66132381&db_name=08791392&lang=lg-eng&recursive=false&term_id=72336471 HTTP/1.1 Host: target.com User-Agent: Go-http-client/1.1 Content-Length: 0 Content-Type: any Accept-Encoding: gzip
11:25AM INF Response After Redirects HTTP/1.1 403 Forbidden Connection: close Content-Length: 45 Content-Type: application/json Date: Wed, 07 Apr 2021 01:25:28 GMT X-Amzn-Requestid: 7e6b2ea1-c662-4671-9eaa-e8cd31b463f2
User is not authorized to perform this action
# Implementazione Tecnica
## Tipo Dati Intermedio (PRoutes)
Utilizziamo una rappresentazione intermedia delle wordlist e degli schemi json di kitebuilder in kiterunner. Questo ci permette di generare dinamicamente i campi nella wordlist e ricostruire corpi delle richieste/intestazioni e parametri di query a partire da una specifica data.
Il tipo PRoute è composto da parametri Headers, Body, Query e Cookie che sono codificati in `pkg/proute.Crumb`. Il tipo Crumb è un'interfaccia implementata su tipi come UUID, Float, Int, Stringhe Casuali, ecc.
Quando si eseguono conversioni da e verso file txt, json e kite, tutte le conversioni vengono prima effettuate sul tipo intermedio `proute.API`. Quindi viene scritta la codifica corrispondente
## Formato File Kite
Utilizziamo un super segreto formato file kite per memorizzare gli schemi json da kitebuilder. Questi sono semplicemente `pkg/proute.APIS` codificati in protobuf scritti in un file. La compilazione viene utilizzata per permetterci di deserializzare rapidamente la wordlist già analizzata. Questo formato file non è stabile e dovrebbe essere utilizzato solo con gli strumenti di conversione integrati di kiterunner.
Quando viene rilasciata una nuova versione del formato file kite, potrebbe essere necessario ricompilare i file kite