assetnote/kiterunnerFerramenta de descoberta de conteúdo web e API de alta velocidade que realiza brute force em rotas usando conjuntos de dados Swagger compilados, suportando varredura em profundidade, listas de palavras personalizadas e varredura simultânea de hosts.
Por muito tempo, a descoberta de conteúdo focou-se em encontrar arquivos e pastas. Embora essa abordagem seja eficaz para servidores web legados que hospedam arquivos estáticos ou respondem com 3xx's em um caminho parcial, ela não é mais eficaz para aplicações web modernas, especificamente APIs.
Com o tempo, vimos muito tempo investido em tornar as ferramentas de descoberta de conteúdo mais rápidas para que listas de palavras maiores possam ser usadas, no entanto a arte da descoberta de conteúdo não foi inovada.
Kiterunner é uma ferramenta capaz de não apenas realizar descoberta de conteúdo tradicional em velocidades extremamente rápidas, mas também fazer bruteforce de rotas/endpoints em aplicações modernas.
Frameworks modernos de aplicação como Flask, Rails, Express, Django e outros seguem o paradigma de definir explicitamente rotas que esperam certos métodos HTTP, cabeçalhos, parâmetros e valores.
Ao usar ferramentas tradicionais de descoberta de conteúdo, essas rotas são frequentemente perdidas e não podem ser facilmente descobertas.
Ao reunir um conjunto de dados de especificações Swagger e condensá-lo em nosso próprio esquema, o Kiterunner pode usar esse conjunto de dados para fazer bruteforce de endpoints de API enviando o método HTTP, cabeçalhos, caminho, parâmetros e valores corretos para cada requisição que envia.
Arquivos Swagger foram coletados de várias fontes de dados, incluindo uma varredura em toda a internet pelos 40+ caminhos Swagger mais comuns. Outras fontes de dados incluíram GitHub via BigQuery e APIs.guru.
Você pode baixar uma cópia pré-compilada em 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
Os conjuntos de dados JSON podem ser encontrados abaixo:
- [routes-large.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-large.json.tar.gz) (118MB compactado, 2.6GB descompactado)
- [routes-small.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-small.json.tar.gz) (14MB compactado, 228MB descompactado)
Alternativamente, é possível baixar os arquivos `.kite` compilados a partir dos links abaixo:
- [routes-large.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-large.kite.tar.gz) (40MB compactado, 183M descompactado)
- [routes-small.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-small.kite.tar.gz) (2MB compactado, 35MB descompactado)
## AUR
Usuários que utilizam uma distribuição baseada em Arch podem baixar o binário pré-compilado do [AUR](https://aur.archlinux.org/packages/kiterunner-bin/)
Você pode usar um "Aur Helper" como `yay` para instalar o kiterunner```
yay -S kiterunner-bin
kr [scan|brute] [flags]
- `<input>` pode ser um arquivo, um domínio ou URI. nós descobriremos para você. Veja [Formatação de Entrada/Host](#inputhost-formatting) para mais detalhes```
# 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")
flags de força bruta (todas as flags acima +)```
-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
Quando fornecido com uma entrada, o kiterunner tentará resolver a entrada na seguinte ordem:
Se você fornecer um "domínio", mas ele existir como um arquivo, por exemplo, google.com mas google.com também é um arquivo txt no diretório atual,
carregaremos google.com o arquivo de texto, porque o encontramos primeiro.
Análise de Domínio
É preferível que você forneça uma URI completa como entrada, no entanto, você pode fornecer URIs incompletos e tentaremos adivinhar o que você quer dizer. Um exemplo de lista de domínios que você pode fornecer são:``` one.com two.com:80 three.com:443 four.com:9447 https://five.com:9090 http://six.com:80/api
A lista de domínios acima se expandirá para a lista subsequente de alvos```
(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)
as regras que aplicamos são:
Quando você tem um alvo único```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
## Força Bruta Padrão```bash
kr brute https://target.com -A=raft-large-words -A=apiroutes-210228:20000 -x 10 -d=0 --ignore-length=34 -ejson,txt
Para quando você tem uma wordlist antiga que ainda contém %EXT% na wordlist, você pode usar -D. isso irá substituir a extensão apenas onde %EXT% estiver presente no caminho```bash
kr brute https://target.com -w dirsearch.txt -x 10 -d=0 --ignore-length=34 -ejson,txt -D
# Características Técnicas
## Varredura por Profundidade
Uma característica principal do kiterunner é a varredura baseada em profundidade. Isso tenta lidar com a detecção de curingas dado o roteamento baseado em caminho de aplicação virtual. A profundidade define quantos níveis de diretórios as verificações de linha de base são executadas, E.g.```bash
~/kiterunner $ cat wordlist.txt
/api/v1/user/create
/api/v1/user/delete
/api/v2/user/
/api/v2/admin/
/secrets/v1/
/secrets/v2/
/ teria as verificações de base realizadas para deteção de curingas/api e /secrets teriam verificações de base realizadas; e essas verificações seriam usadas contra /api e /secrets correspondentemente/api/v1, /api/v2, /secrets/v1 e /secrets/v2 teriam todas verificações de base realizadas.Por padrão, kr scan tem uma profundidade de 1, pois, com base no uso interno, vimos frequentemente que esta é a profundidade mais comum onde ocorre roteamento virtual. kr brute tem uma profundidade padrão de 0, já que normalmente não se deseja que essa verificação seja realizada com uma wordlist estática.
Naturalmente, aumentar a profundidade aumentará a precisão das suas varreduras, no entanto, isso também aumenta o número de requisições ao alvo. (# de verificações de base * # de diretórios de base de profundidade). Portanto, recomendamos não ultrapassar 1 e, em casos raros, ir até a profundidade 2.
Oferecemos download e cache integrados de wordlists do assetnote.io. Pode utilizá-las com a flag -A que recebe uma lista delimitada por vírgulas de aliases ou nomes completos.
Pode obter uma lista completa de todas as wordlists do Assetnote com kr wordlist list.
As wordlists, quando utilizadas, são armazenadas em cache em ~/.cache/kiterunner/wordlists. Quando usadas, estas são compiladas de .txt para .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 |
Ao usar wordlists fornecidas pela assetnote, talvez você não queira usar a wordlist inteira, então você pode optar por usar as primeiras N linhas de uma determinada wordlist usando a head syntax. O formato é <wordlist_name>:<N lines> ao especificar uma wordlist.
Uso```
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
## Configurações de Concorrência/Indo Rápido
O Kiterunner foi feito para ser rápido em muitos hosts. Mas, só porque você pode executar o kiterunner com 20000 goroutines, não significa que seja uma boa ideia. Gargalos e degradação de desempenho ocorrerão com altas contagens de threads devido ao maior tempo gasto agendando goroutines que estão aguardando E/S de rede e troca de contexto do kernel.
Existem duas configurações principais de concorrência para o kiterunner:
- `-x, --max-connection-per-host` - número máximo de conexões abertas que podemos ter em um host. Governado por 1 goroutine cada. Para evitar DOS em um host, recomendamos manter isso em um valor baixo de 5-10. Dependendo da latência para o alvo, isso resultará em média entre 1-5 requisições por segundo por conexão (200ms - 1000ms/req) para um host.
- `-j, --max-parallel-hosts` - número máximo de hosts para escanear a qualquer momento. Governado por 1 supervisor goroutine para cada
Dependendo do hardware a partir do qual você está escaneando, o número 'máximo' de goroutines que você pode executar de forma ideal variará. Em um AWS t3.medium, vimos degradação de desempenho ao ultrapassar 2500 goroutines. Ou seja, 500 hosts x 5 conexões por host (2500) resultaria em desempenho máximo.
Recomendamos **não** executar o kiterunner a partir do seu **macbook**. Devido a otimizações ruins do kernel para altas contagens de E/S e chamadas de sistema Epoll no macOS, notamos um desempenho substancialmente pior (0.3-0.5x) em comparação com a execução do kiterunner em uma instância linux configurada de forma semelhante.
Para maximizar o desempenho ao escanear um alvo individual ou uma grande superfície de ataque, recomendamos as seguintes dicas:
- Inicie uma instância EC2 em uma região geográfica/datacenter semelhante ao(s) alvo(s) que você está escaneando
- Realize alguns benchmarks iniciais contra seu conjunto de alvos com opções variadas de `-x` e `-j`. Recomendamos ter um ponto de partida típico de cerca de `-x 5 -j 100` e aumentar `-j` conforme o uso de CPU/desempenho de rede permitir
## Convertendo entre formatos de arquivo
O Kiterunner também permite converter entre o schema JSON, um arquivo kite e uma wordlist txt padrão.
**Uso**
O formato é decidido pela extensão do tipo de arquivo fornecida pelos campos `<input>` e `<output>`. Suportamos `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 você recebe um monte de saída do kiterunner, pode ser difícil entender imediatamente por que uma requisição está causando um código/comprimento de resposta específico. O Kiterunner oferece um método de reconstruir a requisição a partir das wordlists usadas, incluindo todos os parâmetros de cabeçalho e corpo.
kb replay.--proxy para encaminhar suas requisições, para que possa modificar/repetir/interceptar a requisição usando ferramentas de terceiros, se desejar.11: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
# Implementação Técnica
## Tipo de Dado Intermediário (PRoutes)
Utilizamos uma representação intermediária de wordlists e esquemas json do kitebuilder no kiterunner. Isto permite-nos gerar dinamicamente os campos na wordlist e reconstruir corpos de requisição/cabeçalhos e parâmetros de consulta a partir de uma determinada especificação.
O tipo PRoute é composto por parâmetros de Cabeçalho, Corpo, Consulta e Cookie que são codificados em `pkg/proute.Crumb`. O tipo Crumb é uma interface implementada em tipos como UUIDs, Floats, Ints, Strings Aleatórias, etc.
Ao realizar conversões de e para arquivos txt, json e kite, todas as conversões são feitas primeiro para o tipo intermediário `proute.API`. Em seguida, a codificação correspondente é escrita.
## Formato de Arquivo Kite
Utilizamos um formato de arquivo kite super secreto para armazenar os esquemas json do kitebuilder. Estes são simplesmente `pkg/proute.APIS` codificados em protobuf escritos num arquivo. A compilação é usada para permitir a rápida desserialização da wordlist já analisada. Este formato de arquivo não é estável e deve ser interagido apenas com as ferramentas de conversão incorporadas do kiterunner.
Quando uma nova versão do formato de arquivo kite for lançada, pode ser necessário recompilar seus arquivos kite.