tko-subs

Cet outil permet :

• De vérifier si un sous-domaine peut être pris en contrôle car il a :

  • un CNAME pendant pointant vers un fournisseur CMS (Heroku, Github, Shopify, Amazon S3, Amazon CloudFront, etc.) qui peut être pris en contrôle.
  • un CNAME pendant pointant vers un nom de domaine inexistant.
  • un ou plusieurs enregistrements NS erronés/typoés pointant vers un serveur de noms qui peut être pris en contrôle par un attaquant pour prendre le contrôle des enregistrements DNS du sous-domaine.

• De prendre effectivement le contrôle de ces sous-domaines en fournissant le drapeau -takeover. Actuellement, la prise de contrôle n'est supportée que pour Github Pages et Heroku Apps et par défaut la fonctionnalité de prise de contrôle est désactivée.

• De spécifier vos propres fournisseurs CMS et de les vérifier via le fichier providers-data.csv. Dans ce fichier, vous indiquerez le nom du CMS, sa valeur CNAME, la chaîne que vous souhaitez rechercher et si elle ne fonctionne que via HTTP ou non. Consultez-le pour quelques exemples.

Avertissement : NE SOYEZ PAS UN CRÉTIN !

Inutile de le mentionner, veuillez utiliser cet outil très très prudemment. Les auteurs ne seront pas responsables des conséquences. Par défaut, cet outil ne permet pas de prendre le contrôle de sous-domaines. Si vous voulez le faire, spécifiez simplement le drapeau -takeover.

Prérequis

Nous avons besoin de GO installé. Une fois que vous avez GO, tapez simplement go get github.com/anshumanbh/tko-subs pour télécharger l'outil.

Une fois l'outil téléchargé, tapez tko-subs -h.

La prochaine chose à faire est d'obtenir les informations suivantes :

• Jeton d'accès personnel Github - Assurez-vous que ce jeton a les droits pour créer des dépôts, des références, des contenus, etc. Vous pouvez créer ce jeton ici - https://github.com/settings/tokens
• Nom d'utilisateur et clé API Heroku
• Nom de l'application Heroku - Vous pouvez créer une application statique sur Heroku avec ce que vous voulez afficher sur sa page d'accueil en suivant les instructions ici - https://gist.github.com/wh1tney/2ad13aa5fbdd83f6a489. Une fois que vous avez créé cette application, utilisez ce nom d'application dans le drapeau (voir ci-dessous). Nous utiliserons cette application pour prendre le contrôle du domaine (avec le CNAME pendant pointant vers une autre application Heroku).

NOTE - Vous n'avez besoin de ces valeurs que si vous voulez prendre le contrôle de sous-domaines. Par défaut, ce n'est pas nécessaire.

Paquets Go requis à construire.

go get github.com/bgentry/heroku-go
go get github.com/gocarina/gocsv
go get github.com/google/go-github/github
go get github.com/olekukonko/tablewriter
go get golang.org/x/net/publicsuffix
go get golang.org/x/oauth2
go get github.com/miekg/dns

Comment exécuter ?

Une fois que tout est installé, cd dans le répertoire et tapez : tko-subs -domains=domains.txt -data=providers-data.csv -output=output.csv

Si vous voulez aussi prendre le contrôle, la commande serait : tko-subs -domains=domains.txt -data=providers-data.csv -output=output.csv -takeover -githubtoken=<github-token> -herokuusername=<heroku-username> -herokuapikey=<heroku-api-key> -herokuappname=<heroku-app-name>

Si vous voulez simplement vérifier un seul domaine, tapez : tko-subs -domain <domain-name>

Si vous voulez simplement vérifier plusieurs domaines, tapez : tko-subs -domain <domain-name-1>,<domain-name-2>

Par défaut :

• le drapeau domains est défini sur domains.txt
• le drapeau data est défini sur providers-data.csv
• le drapeau output est défini sur output.csv
• le drapeau takeover n'est pas défini, donc pas de prise de contrôle par défaut
• le drapeau domain n'est PAS défini, donc il vérifiera toujours tous les domaines mentionnés dans le fichier domains.txt. Si le drapeau domain est mentionné, il ne vérifiera que ce domaine et ignorera le fichier domains.txt, même s'il est présent
• le drapeau threads est défini sur 5

Donc, exécuter simplement tko-subs le fera avec les valeurs par défaut mentionnées ci-dessus.

Comment est formaté providers-data.csv ?

name,cname,string,http

• name : Le nom du fournisseur (ex : github)
• cname : Le CNAME utilisé pour mapper un site web au contenu du fournisseur (ex : github.io)
• string : Le message d'erreur retourné pour un sous-domaine non réclamé (ex : "There isn't a GitHub Pages site here")
• http : Utiliser http (pas https, qui est la valeur par défaut) pour se connecter au site (true/false)

Comment est formatée la sortie ?

Domain,CNAME,Provider,IsVulnerable,IsTakenOver,Response

• Domain : Le domaine vérifié
• CNAME : Le CNAME du domaine
• Provider : Le fournisseur que le domaine utilise
• IsVulnerable : Vrai si le domaine est vulnérable, faux sinon
• IsTakenOver : Vrai si le domaine a été pris en contrôle, faux sinon
• Response : Le message avec lequel le sous-domaine a été comparé

Si un enregistrement DNS mort est trouvé, Provider est laissé vide. Si un serveur de noms mal configuré est trouvé, Provider et CNAME sont laissés vides.

Que se passe-t-il sous le capot ?

Cela parcourra tous les domaines (simultanément en utilisant GoRoutines) dans le fichier subdomains.txt et :

• Vérifie s'ils ont un serveur de noms faisant autorité mal configuré ; si oui, nous marquons ce domaine comme vulnérable.
• Vérifie s'ils ont des enregistrements CNAME pendants, c'est-à-dire des enregistrements DNS morts ; si oui, nous marquons ce domaine comme vulnérable.
• Si un sous-domaine réussit ces deux tests, il essaie de le curl pour obtenir une réponse, puis essaie de voir si cette réponse correspond à l'une des chaînes de fournisseur de données mentionnées dans le fichier providers-data.csv.
• Si la réponse correspond, nous marquons ce domaine comme vulnérable.
• Ensuite, selon que le drapeau takeover est mentionné ou non, il essaiera de prendre le contrôle de ce sous-domaine vulnérable.
• Par exemple, pour prendre le contrôle d'une Github Page, le code va :
  • Créer un dépôt
  • Créer une branche gh-pages dans ce dépôt
  • Télécharger CNAME et index.html vers la branche gh-pages de ce dépôt. Ici, CNAME contient le domaine à prendre en contrôle. index.html contient le texte This domain is temporarily suspended qui s'affichera une fois le domaine pris en contrôle.
• De même, pour les applications Heroku, le code va :
  • Ajouter le domaine pendant à votre application Heroku (dont vous fournirez le nom dans le fichier .env)

Travail futur

• Prendre le nom du CMS et l'expression régulière de l'utilisateur ou du fichier .env et les connecter automatiquement à l'outil pour pouvoir les trouver. FAIT
• Ajouter des prises de contrôle pour plus de CMS
• Ajouter plus de fournisseurs CMS

Crédits

• Merci à Luke Young (@TheBoredEng) pour m'avoir aidé avec la bibliothèque go-github.
• Merci à Frans Rosen (@fransrosen) pour m'avoir aidé à comprendre les détails techniques nécessaires pour certaines prises de contrôle.
• Merci à Mohammed Diaa (@mhmdiaa) pour avoir pris le temps d'implémenter la fonctionnalité des données fournisseur et de faire avancer le code.
• Merci à high-stakes pour une rafraîchissement de code bien nécessaire.

Journal des modifications

5/27

• Ajout d'un nouveau Dockerfile réduisant la taille de l'image
• Ajout d'un fichier domains.txt exemple pour tester
• mhmdiaa a ajouté la logique pour les prises de contrôle DNS mortes. Documentation mise à jour. Merci beaucoup !

11/6

• high-stakes émet une PR avec un tas de nouveau code qui corrige quelques bugs et rend le code plus propre

9/22

• Ajout d'un drapeau optionnel pour vérifier un seul domaine
• Rendu plus facile à installer et à exécuter

6/25

• Rendu le code beaucoup plus rapide en implémentant des goroutines
• Au lieu de vérifier avec la fonction LookupCNAME des paquets net de Golang, on utilise simplement dig car cela donne aussi les enregistrements DNS morts. Plus de surface d'attaque !!