assetnote/kiterunnerHerramienta de descubrimiento de contenido web y API de alta velocidad que realiza fuerza bruta en rutas utilizando conjuntos de datos Swagger compilados, compatible con escaneo en profundidad, listas de palabras personalizadas y escaneo concurrente de hosts.
Durante mucho tiempo, el descubrimiento de contenido se ha centrado en encontrar archivos y carpetas. Si bien este enfoque es efectivo para servidores web heredados que alojan archivos estáticos o responden con 3xx ante una ruta parcial, ya no es efectivo para aplicaciones web modernas, específicamente APIs.
Con el tiempo, hemos visto una gran inversión de tiempo para hacer más rápidas las herramientas de descubrimiento de contenido, de modo que se puedan usar listas de palabras más grandes; sin embargo, el arte del descubrimiento de contenido no ha sido innovado.
Kiterunner es una herramienta capaz no solo de realizar descubrimiento de contenido tradicional a velocidades ultrarrápidas, sino también de forzar rutas/endpoints en aplicaciones modernas.
Los marcos de aplicación modernos como Flask, Rails, Express, Django y otros siguen el paradigma de definir explícitamente rutas que esperan ciertos métodos HTTP, encabezados, parámetros y valores.
Al usar herramientas tradicionales de descubrimiento de contenido, dichas rutas a menudo se pasan por alto y no se pueden descubrir fácilmente.
Al recopilar un conjunto de datos de especificaciones Swagger y condensarlo en nuestro propio esquema, Kiterunner puede usar este conjunto de datos para forzar endpoints de API enviando el método HTTP, los encabezados, la ruta, los parámetros y los valores correctos para cada solicitud que envía.
Los archivos Swagger se recopilaron de varias fuentes de datos, incluido un escaneo a nivel de internet de las 40+ rutas Swagger más comunes. Otras fuentes de datos incluyeron GitHub a través de BigQuery y APIs.guru.
Puede descargar una copia precompilada desde 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
Los conjuntos de datos JSON se pueden encontrar a continuación:
- [routes-large.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-large.json.tar.gz) (118MB comprimido, 2.6GB descomprimido)
- [routes-small.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-small.json.tar.gz) (14MB comprimido, 228MB descomprimido)
Alternativamente, es posible descargar los archivos `.kite` compilados desde los siguientes enlaces:
- [routes-large.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-large.kite.tar.gz) (40MB comprimido, 183M descomprimido)
- [routes-small.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-small.kite.tar.gz) (2MB comprimido, 35MB descomprimido)
## AUR
Los usuarios que usen una distribución basada en Arch pueden descargar el binario precompilado desde [AUR](https://aur.archlinux.org/packages/kiterunner-bin/)
Puedes usar un "Aur Helper" como `yay` para instalar kiterunner```
yay -S kiterunner-bin
kr [scan|brute] [flags]
- `<input>` puede ser un archivo, un dominio o una URI. Lo resolveremos por ti. Consulte [Input/Host Formatting](#inputhost-formatting) para más detalles```
# 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")
bruteforce flags (todos los flags anteriores +)```
-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
Cuando se proporciona una entrada, kiterunner intentará resolverla en el siguiente orden:
Si proporcionas un "dominio", pero existe como un archivo, por ejemplo google.com pero google.com también es un archivo txt en el directorio actual,
cargaremos google.com el archivo de texto, porque lo encontramos primero.
Análisis de dominio
Es preferible que proporciones una URI completa como entrada, sin embargo, puedes proporcionar URIs incompletas y trataremos de adivinar a qué te refieres. Una lista de ejemplo de dominios que puedes proporcionar son:``` one.com two.com:80 three.com:443 four.com:9447 https://five.com:9090 http://six.com:80/api
La lista anterior de dominios se expandirá en la siguiente lista de objetivos.```
(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)
las reglas que aplicamos son:
Cuando tienes un solo objetivo```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
## Fuerza Bruta Simple```bash
kr brute https://target.com -A=raft-large-words -A=apiroutes-210228:20000 -x 10 -d=0 --ignore-length=34 -ejson,txt
Para cuando tienes una lista de palabras anticuada que aún contiene %EXT% en la lista, puedes usar -D. Esto solo sustituirá la extensión donde %EXT% esté presente en la ruta.```bash
kr brute https://target.com -w dirsearch.txt -x 10 -d=0 --ignore-length=34 -ejson,txt -D
# Características Técnicas
## Escaneo de Profundidad
Una característica clave de kiterunner es el escaneo basado en profundidad. Esto intenta manejar la detección de comodines dada la ruta de aplicación virtual basada en enrutamiento. La profundidad define cuántos niveles de directorios se realizan las comprobaciones de línea base. P.ej.```bash
~/kiterunner $ cat wordlist.txt
/api/v1/user/create
/api/v1/user/delete
/api/v2/user/
/api/v2/admin/
/secrets/v1/
/secrets/v2/
/ tendría las comprobaciones de referencia realizadas para la detección de comodines/api y /secrets tendrían comprobaciones de referencia realizadas; y estas comprobaciones se usarían contra /api y /secrets correspondientemente/api/v1, /api/v2, /secrets/v1 y /secrets/v2 tendrían todas las comprobaciones de referencia realizadas.Por defecto, kr scan tiene una profundidad de 1, ya que por uso interno, hemos visto a menudo que esta es la profundidad más común donde ocurre el enrutamiento virtual. kr brute tiene una profundidad predeterminada de 0, ya que normalmente no se desea realizar esta comprobación con una lista de palabras estática.
Naturalmente, aumentar la profundidad incrementará la precisión de sus escaneos, sin embargo, esto también aumenta el número de solicitudes al objetivo. (# of baseline checks * # of depth baseline directories). Por lo tanto, recomendamos no superar 1, y en casos raros, llegar a profundidad 2.
Proporcionamos descarga y almacenamiento en caché integrados de listas de palabras desde assetnote.io. Puede usarlas con la bandera -A que recibe una lista delimitada por comas de alias o nombres completos.
Puede obtener una lista completa de todas las listas de palabras de Assetnote con kr wordlist list.
Las listas de palabras, cuando se usan, se almacenan en caché en ~/.cache/kiterunner/wordlists. Cuando se usan, se compilan de .txt a .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 |
Cuando se usan listas de palabras proporcionadas por assetnote, es posible que no desees usar la lista completa, por lo que puedes optar por usar las primeras N líneas de una lista de palabras determinada usando la sintaxis head. El formato es <wordlist_name>:<N lines> al especificar una lista de palabras.
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
## Configuración de concurrencia / Ir rápido
Kiterunner está diseñado para ir rápido en muchos hosts. Pero, solo porque puedas ejecutar kiterunner con 20000 goroutines, no significa que sea una buena idea. Se producirán cuellos de botella y degradación del rendimiento con recuentos de hilos altos debido a más tiempo dedicado a programar goroutines que están esperando E/S de red y cambios de contexto del kernel.
Hay dos configuraciones principales de concurrencia para kiterunner:
- `-x, --max-connection-per-host` - número máximo de conexiones abiertas que podemos tener en un host. Gobernado por 1 goroutine cada una. Para evitar hacer DoS a un host, recomendamos mantener esto en un rango bajo de 5-10. Dependiendo de la latencia hacia el objetivo, esto generará en promedio entre 1-5 solicitudes por segundo por conexión (200ms - 1000ms/req) a un host.
- `-j, --max-parallel-hosts` - número máximo de hosts a escanear en un momento dado. Gobernado por 1 supervisor de goroutine por cada uno.
Dependiendo del hardware desde el que estés escaneando, la cantidad "máxima" de goroutines que puedes ejecutar de manera óptima variará. En una instancia AWS t3.medium, observamos degradación del rendimiento al superar las 2500 goroutines. Es decir, 500 hosts x 5 conexiones por host (2500) darían el rendimiento máximo.
Recomendamos **no** ejecutar kiterunner desde tu **macbook**. Debido a las malas optimizaciones del kernel para altos recuentos de E/S y llamadas al sistema Epoll en macOS, notamos un rendimiento sustancialmente peor (0.3-0.5x) en comparación con ejecutar kiterunner en una instancia linux configurada de manera similar.
Para maximizar el rendimiento al escanear un objetivo individual, o una superficie de ataque grande, recomendamos los siguientes consejos:
- Levanta una instancia EC2 en una región geográfica/datacenter similar al objetivo(s) que estás escaneando
- Realiza algunas pruebas de referencia iniciales contra tu conjunto de objetivos con opciones variables de `-x` y `-j`. Recomendamos tener un punto de partida típico de alrededor de `-x 5 -j 100` y mover `-j` hacia arriba según lo permita tu uso de CPU/rendimiento de red
## Conversión entre formatos de archivo
Kiterunner también te permitirá convertir entre el JSON de esquema, un archivo kite y una lista de palabras txt estándar.
**Uso**
El formato se decide por la extensión del tipo de archivo proporcionada por los campos `<input>` y `<output>`. Soportamos `txt`, `json` y `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
Cuando recibes un montón de resultados de kiterunner, puede ser difícil entender de inmediato por qué una solicitud está generando un código/longitud de respuesta específica. Kiterunner ofrece un método para reconstruir la solicitud a partir de las listas de palabras utilizadas, incluyendo todos los parámetros de encabezado y cuerpo.
kb replay.--proxy para reenviar tus solicitudes a través de él, de modo que puedas modificar/repetir/interceptar la solicitud usando herramientas de terceros si lo deseas.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
# Implementación Técnica
## Tipo de Datos Intermedio (PRoutes)
Usamos una representación intermedia de wordlists y esquemas json de kitebuilder en kiterunner. Esto es para permitirnos generar dinámicamente los campos en el wordlist y reconstruir cuerpos de solicitud/encabezados y parámetros de consulta a partir de un spec dado.
El tipo PRoute está compuesto por parámetros de Headers, Body, Query y Cookie que están codificados en `pkg/proute.Crumb`. El tipo Crumb es una interfaz que se implementa en tipos como UUIDs, Floats, Ints, Random Strings, etc.
Al realizar conversiones hacia y desde archivos txt, json y kite, todas las conversiones se hacen primero al tipo intermedio `proute.API`. Luego se escribe la codificación correspondiente
## Formato de Archivo Kite
Usamos un formato de archivo kite súper secreto para almacenar los esquemas json de kitebuilder. Estos son simplemente protobuf encoded `pkg/proute.APIS` escritos en un archivo. La compilación se usa para permitirnos deserializar rápidamente el wordlist ya analizado. Este formato de archivo no es estable, y solo debe ser manejado con las herramientas de conversión incorporadas de kiterunner.
Cuando se lanza una nueva versión del formato de archivo kite, es posible que necesites recompilar tus archivos kite