assetnote/kiterunnerOutil de découverte de contenu web et d'API haute vitesse qui effectue une attaque par force brute sur les routes en utilisant des jeux de données Swagger compilés, prenant en charge l'analyse en profondeur, des listes de mots personnalisées, et l'analyse simultanée d'hôtes.
Pendant très longtemps, la découverte de contenu s'est concentrée sur la recherche de fichiers et de dossiers. Bien que cette approche soit efficace pour les serveurs web legacy qui hébergent des fichiers statiques ou répondent avec des 3xx’s sur un chemin partiel, elle n'est plus efficace pour les applications web modernes, en particulier les API.
Au fil du temps, nous avons vu beaucoup de temps investi pour rendre les outils de découverte de contenu plus rapides afin que des listes de mots plus grandes puissent être utilisées, mais l'art de la découverte de contenu n'a pas été innové.
Kiterunner est un outil capable non seulement d'effectuer la découverte de contenu traditionnelle à des vitesses fulgurantes, mais aussi de bruteforcer des routes/endpoints dans les applications modernes.
Les frameworks d'applications modernes tels que Flask, Rails, Express, Django et autres suivent le paradigme de définir explicitement des routes qui attendent certaines méthodes HTTP, en-têtes, paramètres et valeurs.
Lors de l'utilisation d'outils de découverte de contenu traditionnels, ces routes sont souvent manquées et ne peuvent pas être facilement découvertes.
En collectant un ensemble de données de spécifications Swagger et en le condensant dans notre propre schéma, Kiterunner peut utiliser cet ensemble de données pour bruteforcer des endpoints d'API en envoyant la méthode HTTP, les en-têtes, le chemin, les paramètres et les valeurs corrects pour chaque requête qu'il envoie.
Les fichiers Swagger ont été collectés à partir de plusieurs sources de données, y compris un scan internet large pour les 40+ chemins Swagger les plus courants. D'autres sources de données incluaient GitHub via BigQuery, et APIs.guru.
Vous pouvez télécharger une copie pré-construite depuis 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
Les ensembles de données JSON sont disponibles ci-dessous :
- [routes-large.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-large.json.tar.gz) (118MB compressé, 2.6GB décompressé)
- [routes-small.json](https://wordlists-cdn.assetnote.io/rawdata/kiterunner/routes-small.json.tar.gz) (14MB compressé, 228MB décompressé)
Alternativement, il est possible de télécharger les fichiers `.kite` compilés depuis les liens ci-dessous :
- [routes-large.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-large.kite.tar.gz) (40MB compressé, 183MB décompressé)
- [routes-small.kite](https://wordlists-cdn.assetnote.io/data/kiterunner/routes-small.kite.tar.gz) (2MB compressé, 35MB décompressé)
## AUR
Les utilisateurs d'une distribution basée sur Arch peuvent télécharger le binaire pré-compilé depuis [AUR](https://aur.archlinux.org/packages/kiterunner-bin/)
Vous pouvez utiliser un "Aur Helper" comme `yay` pour installer kiterunner```
yay -S kiterunner-bin
kr [scan|brute] [flags]
- `<input>` peut être un fichier, un domaine ou une URI. Nous nous en occuperons pour vous. Voir [Input/Host Formatting](#inputhost-formatting) pour plus de détails```
# 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")
drapeaux de bruteforce (tous les drapeaux ci-dessus +)```
-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
Lorsqu'une entrée est fournie, kiterunner tentera de la résoudre dans l'ordre suivant :
Si vous fournissez un "domaine", mais qu'il existe en tant que fichier, par exemple google.com mais que google.com est aussi un fichier txt dans le répertoire courant,
nous chargerons google.com le fichier texte, parce que nous l'avons trouvé en premier.
Analyse du domaine
Il est préférable de fournir une URI complète comme entrée, mais vous pouvez fournir des URI incomplètes et nous essaierons de deviner ce que vous voulez dire. Voici un exemple de liste de domaines que vous pouvez fournir :``` one.com two.com:80 three.com:443 four.com:9447 https://five.com:9090 http://six.com:80/api
La liste de domaines ci-dessus se développera en la liste de cibles suivante```
(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)
les règles que nous appliquons sont :
Lorsque vous avez une seule cible```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
## Bruteforce classique```bash
kr brute https://target.com -A=raft-large-words -A=apiroutes-210228:20000 -x 10 -d=0 --ignore-length=34 -ejson,txt
Pour le cas où vous avez une wordlist à l'ancienne qui contient encore %EXT% dans la liste, vous pouvez utiliser -D. Cela ne substituera l'extension que là où %EXT% est présent dans le chemin.```bash
kr brute https://target.com -w dirsearch.txt -x 10 -d=0 --ignore-length=34 -ejson,txt -D
# Fonctionnalités techniques
## Analyse en profondeur
Une fonctionnalité clé de kiterunner est l'analyse basée sur la profondeur. Cela tente de gérer la détection des wildcards en tenant compte du routage basé sur les chemins d'application virtuels. La profondeur définit combien de niveaux de répertoires les vérifications de base sont effectuées, par exemple.```bash
~/kiterunner $ cat wordlist.txt
/api/v1/user/create
/api/v1/user/delete
/api/v2/user/
/api/v2/admin/
/secrets/v1/
/secrets/v2/
/ aurait les vérifications de base effectuées pour la détection de caractères génériques./api et /secrets auraient les vérifications de base effectuées ; et ces vérifications seraient utilisées respectivement pour /api et /secrets./api/v1, /api/v2, /secrets/v1 et /secrets/v2 auraient tous les vérifications de base effectuées.Par défaut, kr scan a une profondeur de 1, car d'après l'utilisation interne, nous avons souvent constaté que c'est la profondeur la plus courante où le routage virtuel se produit. kr brute a une profondeur par défaut de 0, car vous ne voulez généralement pas que cette vérification soit effectuée avec une liste de mots statique.
Naturellement, augmenter la profondeur améliorera la précision de vos scans, mais cela augmente également le nombre de requêtes vers la cible. (# de vérifications de base * # de répertoires de base de profondeur). Par conséquent, nous déconseillons de dépasser 1, et dans de rares cas, d'aller jusqu'à la profondeur 2.
Nous fournissons le téléchargement et la mise en cache intégrés des listes de mots provenant d'assetnote.io. Vous pouvez les utiliser avec l'option -A qui accepte une liste d'alias séparés par des virgules ou des noms complets.
Vous pouvez obtenir une liste complète de toutes les listes de mots Assetnote avec kr wordlist list.
Les listes de mots, lorsqu'elles sont utilisées, sont mises en cache dans ~/.cache/kiterunner/wordlists. Lorsqu'elles sont utilisées, elles sont compilées de .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 |
When using assetnote provided wordlists, you may not want to use the entire wordlist, so you can opt to use the first N lines in a given wordlist using the head syntax. The format is <wordlist_name>:<N lines> when specifying a wordlist.
Utilisation```
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
## Paramètres de concurrence/Aller vite
Kiterunner est conçu pour aller vite sur un grand nombre d'hôtes. Mais, ce n'est pas parce que vous pouvez exécuter kiterunner avec 20000 goroutines que c'est une bonne idée. Des goulots d'étranglement et une dégradation des performances se produiront avec un nombre élevé de threads en raison du temps accru passé à planifier des goroutines qui attendent les E/S réseau et les changements de contexte du noyau.
Il existe deux principaux paramètres de concurrence pour kiterunner :
- `-x, --max-connection-per-host` - nombre maximum de connexions ouvertes que nous pouvons avoir sur un hôte. Chaque connexion est gérée par 1 goroutine. Pour éviter de DOSser un hôte, nous recommandons de maintenir cette valeur dans une plage basse de 5-10. Selon la latence vers la cible, cela produira en moyenne entre 1 et 5 requêtes par seconde par connexion (200 ms - 1000 ms/req) vers un hôte.
- `-j, --max-parallel-hosts` - nombre maximum d'hôtes à scanner à un moment donné. Chaque hôte est géré par 1 superviseur de goroutine.
Selon le matériel à partir duquel vous scannez, le nombre « maximum » de goroutines que vous pouvez exécuter de manière optimale variera. Sur un AWS t3.medium, nous avons observé une dégradation des performances au-delà de 2500 goroutines. Cela signifie que 500 hôtes x 5 connexions par hôte (2500) donneraient des performances de pointe.
Nous recommandons de **ne pas** exécuter kiterunner depuis votre **macbook**. En raison de mauvaises optimisations du noyau pour les nombres élevés d'E/S et les appels système Epoll sur macOS, nous avons constaté des performances nettement inférieures (0,3-0,5x) par rapport à l'exécution de kiterunner sur une instance Linux configurée de manière similaire.
Pour maximiser les performances lors du scan d'une cible individuelle ou d'une grande surface d'attaque, nous recommandons les conseils suivants :
- Lancez une instance EC2 dans une région géographique/datacenter similaire à la/aux cible(s) que vous scannez
- Effectuez quelques benchmarks initiaux sur votre ensemble de cibles avec différentes options `-x` et `-j`. Nous recommandons un point de départ typique d'environ `-x 5 -j 100` et d'augmenter `-j` à mesure que votre utilisation CPU/performances réseau le permettent
## Conversion entre formats de fichiers
Kiterunner vous permet également de convertir entre le schéma JSON, un fichier kite et une wordlist texte standard.
**Utilisation**
Le format est déterminé par l'extension de fichier fournie par les champs `<input>` et `<output>`. Nous supportons `txt`, `json` et `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
Lorsque vous recevez un grand nombre de résultats de kiterunner, il peut être difficile de comprendre immédiatement pourquoi une requête provoque un code/longueur de réponse spécifique. Kiterunner propose une méthode pour reconstruire la requête à partir des listes de mots utilisées, incluant tous les paramètres d'en-tête et de corps.
kb replay.--proxy pour rediriger vos requêtes via un proxy, afin de pouvoir modifier/répéter/intercepter la requête à l'aide d'outils tiers si vous le souhaitez.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
# Implémentation technique
## Type de données intermédiaire (PRoutes)
Nous utilisons une représentation intermédiaire des wordlists et des schémas json de kitebuilder dans kiterunner. Cela nous permet de générer dynamiquement les champs de la wordlist et de reconstruire les corps/headers des requêtes ainsi que les paramètres de requête à partir d'une spécification donnée.
Le type PRoute est composé de paramètres Headers, Body, Query et Cookie qui sont encodés dans `pkg/proute.Crumb`. Le type Crumb est une interface qui est implémentée sur des types tels que UUIDs, Floats, Ints, Random Strings, etc.
Lors des conversions vers et depuis des fichiers txt, json et kite, toutes les conversions sont d'abord effectuées vers le type intermédiaire `proute.API`. Ensuite, l'encodage correspondant est écrit.
## Format de fichier Kite
Nous utilisons un format de fichier kite super secret pour stocker les schémas json provenant de kitebuilder. Ce sont simplement des fichiers encodés en protobuf `pkg/proute.APIS` écrits dans un fichier. La compilation est utilisée pour nous permettre de désérialiser rapidement la wordlist déjà analysée. Ce format de fichier n'est pas stable et ne doit être utilisé qu'avec les outils de conversion intégrés de kiterunner.
Lorsqu'une nouvelle version du format de fichier kite est publiée, vous devrez peut-être recompiler vos fichiers kite.