Recon Everything

Pour suivre nos dernières actualités n'oubliez pas de vous abonner :
Publicité :

Vous pouvez télécharger cet article au format pdf (belle mise en forme) :

https://eduba.school/recon-everything-pdf/

-------------------------------------------

Recon Everything

Toujours lire le code source

Vous allez choisir un programme offrant un large éventail de possibilités. Vous voudrez également rechercher un programme  qui va gérer le plus grand nombre de vulnérabilités possible.

Avoir un gros programme généraliste (ex: Burp) permet au bounty hunters de mieux s’y retrouver.

Explorez les informations sur les domaines, les serveurs de messagerie et les connexions aux réseaux sociaux.

Fouillez le site web, vérifiez chaque requête et réponse et analysez-les, essayez de comprendre leur infrastructure, par exemple comment ils gèrent les sessions et l'authentification, quel type de protection CSRF ils ont (le cas échéant).

Utilisez des tests négatifs pour éliminer l'erreur, les informations sur les erreurs aident beaucoup à trouver les chemins internes du site web. Prenez le temps de comprendre le flux de l'application pour avoir une meilleure idée du type de vulnérabilités à rechercher.

Commencez à creuser l'utilisation de scripts pour tester les "end points" au travers une wordlist. Cela peut vous aider à trouver de nouveaux répertoires ou dossiers que vous n'avez peut-être pas pu trouver en consultant simplement le site web. 

Il s'agit généralement de répertoires d'administration privés, de dépôts de sources qu'ils ont oublié de supprimer, comme les dossiers /.git/, ou de scripts de test ou de débogage. 

Après cela, vérifiez chaque formulaire du site web puis essayez de pousser les attaques côté client. Utilisez plusieurs charges utiles (playloads) pour contourner les filtres côté client.

Commencez tôt. Dès qu'un programme est lancé, commencez à chasser immédiatement, si vous le pouvez

Une fois que vous avez commencé à chasser, choisissez une fonctionnalité/un workflow de travail particulier dans l'application et commencez à l'approfondir. J'ai cessé de me préoccuper outils merdiques qui ne font que capter mon attention. Il ne sert à rien de concentrer vos efforts sur eux.

Supposons qu'une application possède une fonctionnalité qui permet aux utilisateurs d'envoyer des courriels à d'autres utilisateurs.


Observons le workflow et les requêtes via un outil proxy tel que Burp.  Burp est à peu près le seul outil que j'utilise pour tester les applications web.

Créez plusieurs comptes car vous voudriez tester les e-mails envoyés d'un utilisateur à un autre. Si vous n'avez pas encore de comptes multiples, faites-les. Jusqu'à présent, on ne m'a pas interdit de créer un deuxième compte chaque fois que j'en ai fait la demande.

Maintenant, si vous avez un peu d'expérience, après quelques minutes de bidouillage, vous sentirez s'il y a quelque chose d'intéressant ou non. Ce point est difficile à expliquer. Il viendra avec la pratique.

Si ce qui précède est vrai, commencez à fuzzer, à briser le flux de travail de l'application (break the workflow), à insérer des ID aléatoires, des valeurs, etc. dans la mesure du possible. Dans 80 % des cas, vous finirez par remarquer des comportements étranges

Ce comportement bizarre ne signifie pas nécessairement que vous avez trouvé un bogue qui mérite d'être signalé. 

Cela signifie probablement que vous avez de bonnes chances de le trouver et que vous devriez continuer à le chercher.

Des recherches pourraient également être nécessaires. Supposons que vous ayez trouvé une version obsolète d'un serveur de courrier électronique utilisé. Recherchez sur Internet les vulnérabilités connues de ce serveur. 

Vous pourriez rencontrer un CVE connu avec un exploit connu. Essayez cet exploit et voyez ce qui se passe (attention d'avoir l'aval du propriétaire de l'application).

Il se peut que des outils spéciaux soient nécessaires. Renseignez-vous à ce sujet, si possible. 

N'oubliez pas que Burp est un couteau suisse, mais que vous devrez peut-être utiliser certains outils spécifiques dans certains cas. Soyez toujours conscient de cela.

Après avoir passé quelques heures sur ce sujet, si vous pensez avoir épuisé toutes vos options et que vous n'en retirez rien de significatif, arrêtez-vous et passez à autre chose. 

S'accrocher à quelque chose est le plus grand tueur de motivation, mais cela ne veut pas dire que vous abandonnez. Revenez-y plus tard si quelque chose d'autre se présente. Prenez-en note.

Ce qui a fonctionné pour moi, c'est la vérification des paramètres, choisissez un paramètre qui a un effet évident sur le déroulement de l'application.

Par exemple, si un champ prend un numéro (appelons-le ID).

  • Que se passe-t-il si :
  • vous mettez un chiffre négatif ?
  • vous augmentez ou diminuez le nombre ?
  • vous mettez un nombre très grand ?
  • vous mettez une chaîne de caractères ou un symbole ?
  • vous essayez de parcourir un répertoire avec .../
  • vous mettez des vecteurs XSS ?
  • vous mettez des vecteurs SQLI ?
  • vous mettez des caractères non-ascii ?
  • vous vous trompez sur le type de variable, par exemple en utilisant une chaîne de caractères dans un tableau
  • vous utilisez des caractères nuls ou sans valeur
  • Je verrais alors si je peux tirer des conclusions des résultats de ces tests voir si je peux comprendre ce qui se passe sur la base d'une erreur -est tout ce qui est cassé ou exposé
  • Cette action peut-elle affecter d'autres éléments de l'application ?

Concentrez-vous sur les fonctionnalités du site qui ont été redessinées ou modifiées depuis une version précédente.

 Parfois, après avoir vu/utilisé une étude de cas (CTF, CVE, vulnhub, walkthrough) auparavant, vous constaterez tout de suite que de nouvelles fonctionnalités ont été ajoutées au site/application.

D'autres fois, vous lirez des comptes rendus qui vous aideront à mieux connaître la cartographie de cette dernière.

Les développeurs on tendance à souligner voir préciser leurs propres faiblesses que ce soit dans leurs gestion du code ou tout simplement en commentaires. Indirectement ils vont être les premiers supporters de votre réussite ou de leurs propre désintégration.

Une nouveauté qui pourrait nous intéresser serait ... la mise en place d'une fonctionnalité de recherche, le changement de gestion des rôles ...

Un brief technique offert par l'équipe serait un moyen de remarquer de nombreuses références utiles/sensibles de  l'API ou à une page ou fonction particulière du site.

Si la situation le permet (et si vous avez les compétences requises), testez les applications mobiles.

Alors que les bogues côté client continuent de s'atténuer, les API/points d'accès Internet avec lesquels les applications mobiles dialoguent touchent souvent des parties de l'application que vous n'auriez pas vues dans un workflow normal.

Cela ne veut pas dire que les bogues côté client ne doivent pas être signalés, ils deviennent simplement des problèmes de faible gravité à mesure que les systèmes d'exploitation mobiles élèvent la barre en matière de sécurité.

Ainsi, après avoir acquis une bonne "intuition" du site, vous devez conserver mentalement ou physiquement un enregistrement de votre workflow, et de celui de l'application. Vous devez commencer à vous poser ce genre de questions :

  • La fonctionnalité de la page affiche-t-elle quelque chose pour les utilisateurs ? (XSS, usurpation de contenu, etc.)
  • La page semble-t-elle devoir faire appel à des données stockées ? (Injections de tout type, références indirectes d'objets, stockage côté client)
  • Interagit-elle (ou peut-elle interagir) avec le système de fichiers du serveur ? (Téléchargement/uploads de fichiers vulns, LFI, etc.)
  • Est-ce une fonction digne d'être sécurisée ? (CSRF, mode mixte)
  • Cette fonction est-elle privilégiée ? (défauts de logique, IDORs, escalades privées)++
  • Est ce que la saisie est acceptée et potentiellement affichée à l'utilisateur ?
  • Quels sont les end points qui sauvegardent les données ?
  • Y a-t-il une fonctionnalité de téléchargement/upload de fichiers ?
  • Quel type d'authentification est utilisé ?

Mesures à prendre à l'approche d'une cible

1. Contrôler/vérifier la portée (scope) de la cible (*.example.com)

2. Trouver les sous-domaines de la cible (Voir les outils de sous-domaine mentionnés dans l'article)

3. Executer masscan

4. Vérifier quels domaines sont résolus

5. Prendre un screenshot

6. Faire de la découverte de contenu (en forçant les fichiers et les répertoires sur un domaine/sous-domaine particulier)

Web Tools:

https://pentest-tools.com/

https://virustotal.com/

https://www.shodan.io/

https://crt.sh/?q=%25target.com

https://dnsdumpster.com/

https://censys.io

http://dnsgoodies.com


----------------

ATTENTION

Avant d’entrer dans le vif du sujet, nous précisons :

  • Que certains outils cités demandent une connaissance avancée
  • Que la majorité des configurations sont faites sur une distribution linux (Kali Linux, Ubuntu, Debian) et que toutes utilisations sur windows, mac risque d’endommager votre système d’exploitation (vous pouvez opter d’aller sur un container docker, avoir une machine virtuelle). RENSEIGNEZ VOUS !
  • Que les lignes débutant par le signe $, indiquent une exécution sur le terminal. 
  • Que certaines commandes ne fonctionnent pas en copier collé
  • Qu’il est important pour vous de savoir comment utiliser chmod et de connaître le fonctionnement des chemins (path) sur votre OS
  • Que certains outils ont peut être été mis à jours ou ne sont plus entretenus
  • Qu’en installant des outils hors environnement virtuel, cela peut casser le circuit de dépendances de votre ordinateur, donc ne plus rendre fonctionnel certains outils
  • Que vous devez vérifier les versions des langages de programmation utilisés
  • Que si vous n’êtes pas patients et que vous ne vous préparez pas à avoir des galères, ce que l’on vous montre n’est pas pour vous
  • Qu’il existe souvent des moyens alternatifs d'installation (soit par les managers de paquets d’une distribution : apt, yum, pacman ou par les gestionnaires de paquets du langage de programmation : pip, npm ….)


Maintenant que les problèmes de bon sens ont été énoncés, nous vous rapportons que le pdf (avec une meilleure mise en page est disponible en bas pour téléchargement)

-------------------

Recon

La reconnaissance ne doit pas se limiter à la recherche de biens et de choses périmées. Il s'agit aussi de comprendre l'application et de trouver des fonctionnalités qui ne sont pas facilement accessibles. Pour réussir, il faut trouver un équilibre entre la reconnaissance et le bon vieux piratage de l'application - @NahamSec

Subdomain Enumeration Tools:

  • Il est recommandé de passer par les liens github pour l'utilisation des outils.

Énumération des domaines (Remarque : lorsque vous voyez bigdash( -- ) ci-dessous, il s'agit en fait de deux tirets ensemble(- -), medium post a converti deux tirets ensemble avec l'espace en un seul gros tiret)

a. Corrélation verticale des domaines (tout le sous-domaine d'un domaine) (maps.google.com) → Tout sous-domaine d'un domaine de base particulier

b. Corrélation horizontale de domaines ( comme google.com, google.cz, youtube.com, blogger.com) → tout ce qui est acquis par Google en tant qu'entité.

1. Sublist3r https://github.com/aboul3la/Sublist3r

“RAPPEL” >  Préferez l’utilisation des outils dans un environnement virtuel

Exemple avec python3 :

$ cd home/user/dossier/


home/user/dossier/ - $ python3 -m venv venv


home/user/dossier/ - $ source venv/bin/activate/


(venv) home/user/dossier/ - $ pip install toolname


L’exécution des scripts se fait aussi dans l’environnement virtuel

Pour l'exécution à l’extérieur d’un venv : 

https://stackoverflow.com/questions/11963019/running-python-script-from-inside-virtualenv-bin-is-not-working

Setup:

$ git clone https://github.com/aboul3la/Sublist3r.git


$ sudo pip install -r requirements.txt

Usage:

Pour énumérer les sous-domaines d'un domaine spécifique :

$ python sublist3r.py -d example.com

Alias:

$ alias sublist3r='python /path/to/Sublist3r/sublist3r.py -d '


Les alias vous permettent de faciliter l'exécution via le terminal et offre une possibilité si le chemin du script est absolu, d’exécuter le code ou que vous soyez)


Je vous invite si vous êtes sous linux à mettre vos alias dans le fichier .bash_aliases, qui sera à créer de votre côté au niveau de /home/user/


$ alias sublist3r-one=". <(cat domains | awk '{print "sublist3r "$1 " -o " $1 ".txt"}')"


2. subfinder https://github.com/subfinder/subfinder

Setup:

$ go get github.com/subfinder/subfinder


Ici l’outil est installé via go, vous pouvez peut être l’installer via apt ?

Usage:

$ subfinder -d freelancer.com


$ ./subfinder -dL hosts.txt


info : comme au dessus vous pouvez préférer un alias pour avoir la capacité à sortir d’une exécution “in vitro”

Pour trouver le domaine de façon récursive :

$ subfinder -d <domain> -recursive -silent -t 200 -v -o <outfile>

Pour utiliser les capacités de bruteforcing, vous pouvez utiliser le drapeau -b avec l'option -w pour spécifier une liste de mots.

$ ./subfinder -d freelancer.com -b -w jhaddix_all.txt -t 100 -- sources censys -- set-settings CensysPages=2 -v

La commande -o peut être utilisée pour spécifier un fichier de sortie.

3. findomain https://github.com/Edu4rdSHL/findomain

Vous pouvez surveiller les sous-domaines et fournir les webhooks pour obtenir des notifications sur slack et discorde.

Setup:

$ wget https://github.com/Edu4rdSHL/findomain/releases/latest/download/findomain-linux


$ chmod +x findomain-linux


Ici on vous indique que l’utilisateur doit créer une permission d’exécution du fichier

Usage:

$ findomain -t example.com


4. assetfinder — https://github.com/tomnomnom/assetfinder

Trouvez les domaines et sous-domaines potentiellement liés à un domaine donné.

Setup:

$ go get -u github.com/tomnomnom/assetfinder

Usage:

$ assetfinder -subs-only <domain>


$ cat domains | assetfinder -subs-only 

( s'assurer que le fichier des domaines est sans http:// ou https://)

5. Amass: https://github.com/OWASP/Amass

Setup:

$ go get -u github.com/OWASP/Amass/...

Usage:

$ amass enum -o subdomains.txt -d output_file.txt

or

$ amass enum -o out.txt -df domains.txt

Tous les domaines découverts sont passés par le whois inverse (sous-domaine horizontal enum)

$ amass intel -whois -d example.com

6. censys-enumeration https://github.com/0xbharath/censys-enumeration

C'est l'étape la plus importante, parce que les noms de sous-domaines que vous trouvez ici, vous ne pouvez pas les trouver à partir d'autres outils de force brute parce que votre liste de mots n'a pas de pattern qui sont disponibles dans tous les sous-domaines ou n'a pas de mot clé comme gateway ou payment qui font partie du sous-domaine.

search query — 443.https.tls.certificate.parsed.extensions.subject_alt_name.dns_names:snapchat.com

Un script pour extraire les sous-domaines/emails pour un domaine donné en utilisant l'ensemble de données des certificats SSL/TLS sur Censys

Setup:

Cloner ce repo

$ git clone git@github.com:yamakira/censys-enumeration.git

– Install dependencies

$ pip install -r requirements.txt

– Obtenez l'ID API Censys et le secret API Censys en créant un compte sur https://censys.io

– Ajoutez l'ID API Censys et le secret API Censys sous les noms CENSYS_API_ID et CENSYS_API_SECRET respectivement aux variables d'environnement du système d'exploitation. Sous Linux, vous pouvez utiliser une commande similaire à la suivante pour ce faire

$ export python censys_enumeration.py -- no-emails -- verbose -- outfile results.json domains.txt

Usage:

$ python censys_enumeration.py -- no-emails -- verbose -- outfile results.json domains.txt

7. altdns https://github.com/infosec-au/altdns

– Il génère les combinaisons possibles du domaine d'origine avec les mots de la liste de mots (https://github.com/infosec-au/altdns/blob/master/words.txt).

Setup:

$ pip install py-altdns

Usage:

$ python altdns.py -i input_domains.txt -o ./output/path -w

$ altdns/words.txt -i subdomains.txt -o data_output -w words.txt -s results_output.txt

8. Massdns: https://github.com/blechschmidt/massdns

Attention, j’ai rencontré des bugs avec l’appel des dns quand je suis sur vpn

Setup:

$ git clone https://github.com/blechschmidt/massdns.git
$ cd massdns
$ make

Usage:

$ ./bin/massdns [options] [domainlist]

Résoudre tous les enregistrements A des domaines dans domains.txt en utilisant les résolveurs dans resolvers.txt dans des listes et stocker les résultats dans results.txt :

$ ./bin/massdns -r lists/resolvers.txt -t A domains.txt > results.txt

9. domains-from-csp https://github.com/0xbharath/domains-from-csp

L'en-tête Content-Security-Policy nous permet de créer une liste blanche de sources de contenu de confiance, et indique au navigateur de n'exécuter ou ne rendre que les ressources provenant de ces domaines (sources).

Setup:

$ git clone git@github.com:yamakira/censys-enumeration.git


$ pipenv install

Usage:

# python csp_parser.py target_url


# python csp_parser.py target_url -- resolve


10. Utiliser les SPF record des DNS https://github.com/0xbharath/assets-from-spf/

Un script Python pour analyser les netblocks et les noms de domaine à partir de l'enregistrement DNS SPF (Sender Policy Framework)

Pour chaque actif analysé, le script trouvera et imprimera également les détails du numéro de système autonome (ASN)

Setup:

$ git clone git@github.com:yamakira/assets-from-spf.git


$ python assets_from_spf.py target_url

Usage:

– Analyser l'enregistrement du SPF pour les actifs mais ne pas faire le recensement de l'ASN

$ python assets_from_spf.py target_url

– Analyser l'enregistrement du SPF pour les actifs et faire le recensement de l'ASN

$ python assets_from_spf.py target_url -- asn

Récupérer le numéro ASN:

Numéro de système autonome (ASN) -> http://bgp.he.net -> consultez par exemple tesla.com et vérifiez les préfixes V4 pour obtenir la plage IP

ou

$ curl -s http://ip-api.com/json/192.30.253.113 | jq -r .as AS36459 GitHub, Inc.

– Les numéros ASN trouvés peuvent être utilisés pour trouver les netblocks du domaine.

– Nous pouvons utiliser des requêtes WHOIS avancées pour trouver toutes les plages d'IP qui appartiennent à un ASN

$ whois -h whois.radb.net -- '-i origin AS36459' | grep -Eo "([0-9.]+){4}/[0-9]+" | uniq

Il existe un script Nmap pour trouver les plages d'IP qui appartiennent à un ASN https://nmap.org/nsedoc/scripts/targets-asn.html

$ nmap -- script targets-asn -- script-args targets-asn.asn=17012 > paypal.txt

Nettoyez la sortie du résultat nmap ci-dessus, prenez tous les IP dans un fichier et lancez ensuite un scan de version ou un masscan sur eux.

$ nmap -p- -sV -iL paypal.txt -oX paypal.xml


– vous pouvez utiliser dig

$ dig AXFR @<nameserver> <domain_name>

11. Certspotter https://certspotter.com/api/v0/certs?domain=hackerone.com

– Bon pour la corelation verticale et horizontale

– vous pouvez obtenir des noms de domaine, des noms de sous-domaine

– l'adresse électronique dans un certificat

#!/bin/bash

find-cert() {

curl -s https://certspotter.com/api/v0/certs?domain=$1 | jq -c '.[].dns_names' | grep -o '"[^"\+"';
}

12. Crt.sh https://crt.sh/?q=%25domain.com

13. knockpy https://github.com/guelfoweb/knock.git

Setup:

$ sudo apt-get install python-dnspython


$ git clone https://github.com/guelfoweb/knock.git

Définissez votre virustotal API_KEY :

$ nano knockpy/config.json


$ sudo python setup.py install

Usage:

$ knockpy domain.com -w wordlist.txt

14. Shodan -

Ports:8443, 8080

Title: “Dashboard[Jenkins]”

Product: Tomcat

Hostname: example.com

Org: google

ssl:Google

To find jenkins instance in a target:

org:{org name;x-jenkins:200}

15. Viewdns.info (énumération horizontale des domaines) Recherche inversée de whois - si vous connaissez l'adresse électronique du bureau d'enregistrement d'un domaine et que vous voulez vérifier quels autres domaines sont enregistrés avec la même adresse électronique, vous pouvez utiliser ce site. La plupart des outils ne trouvent pas le recensement horizontal des domaines.

Get email address using -- $ whois <domain.com>

ou recevoir le courrier électronique et les contributions sur ce site web :

https://tools.whoisxmlapi.com/reverse-whois-search

J'ai trouvé que ce site donne plus de domaines que viewdns.info

Il a également la possibilité d'exporter le résultat en CSV.

16. Sublert — https://github.com/yassineaboukir/sublert

Sublert est un outil de sécurité et de reconnaissance qui exploite la transparence des certificats pour surveiller automatiquement les nouveaux sous-domaines déployés par des organisations spécifiques et les certificats TLS/SSL délivrés.

Setup: https://medium.com/@yassineaboukir/automated-monitoring-of-subdomains-for-fun-and-profit-release-of-sublert-634cfc5d7708

$ git clone https://github.com/yassineaboukir/sublert.git && cd sublert


$ sudo pip3 install -r requirements.txt

Usage:

Ajoutons PayPal par exemple :

$ python sublert.py -u paypal.com

Rendons Sublert.py exécutable :

$ chmod u+x sublert.py

Maintenant, nous devons ajouter un nouveau travail de Cron pour programmer l'exécution de Sublert à un moment donné. Pour ce faire, tapez :

$ crontab -e


ouverture du fichier crontab. CTRL X pour quitter (accepter si ok pour sauvegarder)

Ajoutez la ligne suivante à la fin du fichier Cron :

0 */12 * * * cd /root/sublert/ && /usr/bin/python3 sublert.py -r -l >> /root/sublert/sublert.log 2>&1

Jason Haddix (https://twitter.com/jhaddix/status/972926512595746816?lang=en)

L'art perdu de la découverte de la cible LINKED avec la suite Burp :

1) Désactiver le balayage passif

2) Définir les formulaires à soumettre automatiquement

3) Définir le champ d'application du contrôle avancé et utiliser une chaîne de nom de cible (pas un A fully qualified domain name (FQDN) normal)

4) Marchez+souvenez, puis scrapez tous les hôtes de façon récursive !

5) Profit (plus de cibles) !

Outils de découverte de contenu (Directory Bruteforcing)

- Utilisez robots.txt pour déterminer les répertoires (parfois ceux que l’on veut cacher).

- Scrapez l’hôte pour découvrir les potentiels endpoints de l’API 

- vérifiez un port ouvert sur 8443

- Répertoire force brute

- Vérifiez si l’url /admin/ retourne l’erreur 403

- Énumérez puis utiliser du bruteforce pour voir si vous trouvez plus de fichiers/repertoires sur /admin/

-  regardez si /admin/users.php renvoie 200

- Répéter sur d'autres domaines, ports, dossiers, etc.

1. ffuf https://github.com/ffuf/ffuf

Un fuzzer web rapide écrit en Go.

Setup:

$ go get github.com/ffuf/ffuf

Usage:

  • Découverte typique d'un répertoire (dossier) :

$ ffuf -w /path/to/wordlist -u https://target/FUZZ

Testez une liste de mots par le biais de plusieurs hôtes :

$ ffuf -u https://HFUZZ/WFUZZ -w hosts.txt:HFUZZ -w wordlist.txt:WFUZZ -mode clusterbomb

  • Faites figurer votre liste d'hôtes dans une liste de mots séparée, car le ffuf prend désormais en charge plusieurs listes de mots (et de mots-clés)

$ ffuf -w hosts.txt:HOSTS -w content.txt:FUZZ -u https://HOSTS/FUZZ


$ ffuf -u url/FUZZ/FUZZ/FUZZ -w wordlist1.txt -w wordlist2.txt -w wordlist3.txt -mode clusterbomb

Ensuite, il effectuera des demandes de liste de mots1 liste de mots2 liste de mots3.

Découverte d'hôtes virtuels (sans enregistrements DNS)

Déterminez d'abord la durée de réponse d'un faux positif.

$ curl -s -H "Host: nonexistent.example.com" http://example.com | wc -c


$ ffuf -c -w /path/to/wordlist -u http://example.com -H "Host: FUZZ.example.com" -fs <length_of_flase_positive>


fuzzing des paramètres GET

Le fuzzing des noms de paramètres GET est très similaire à la découverte de répertoires, et fonctionne en définissant le mot-clé FUZZ comme faisant partie de l'URL. Cela suppose également une taille de réponse de 4242 octets pour un nom de paramètre GET non valide.

$ ffuf -w /path/to/paramnames.txt -u https://target/script.php?FUZZ=test_value -fs 4242


Si le nom du paramètre est connu, les valeurs peuvent être brouillées de la même manière. Cet exemple suppose qu'une valeur de paramètre erronée renvoie le code de réponse HTTP 401.

$ ffuf -w /path/to/values.txt -u https://target/script.php?valid_name=FUZZ -fc 401

example:

$ ffuf -w params.txt:HFUZZ -H "Cookie: __cfduid=d12ff6c4c7-s 915d707ec42577f244631577769628; 1337session=6430373065623634333431343933" -u http://bugbountylab.art/target/web/recon/paramining-1/?HFUZZ=VFUZZ -w value.txt:VFUZZ -fs 31 -t 150

  • fuzzing data avec POST
    Il s'agit d'une opération très simple, toujours en utilisant le mot-clé FUZZ. Cet exemple n'embrouille qu'une partie de la demande POST. Nous filtrons à nouveau les 401 réponses.

$ ffuf -w /path/to/postdata.txt -X POST -d "username=admin\&password=FUZZ" -u https://target/login.php -fc 401


2. dirsearch https://github.com/maurosoria/dirsearch.git or https://github.com/Damian89/dirsearch

Setup:

$ git clone https://github.com/Damian89/dirsearch.git


$ python3 dirsearch.py -u <URL> -e <EXTENSION>


$ python3 dirsearch.py -e php,txt,zip -u https://target -w db/dicc.txt -- recursive -R 2

Wordlist:

$ wget https://gist.githubusercontent.com/EdOverflow/c4d6d8c43b315546892aa5dab67fdd6c/raw/7dc210b17d7742b46de340b824a0caa0f25cf3cc/open\_redirect\_wordlist.txt

Alias:

$ alias dirsearch='python3 /path/to/dirsearch/dirsearch.py -u '


$ alias dirsearch-one=". <(cat domains | awk '{print "dirsearch "$1 " -e *"}')"


$ alias openredirect=". <(cat domains | awk '{print "dirsearch "$1 " -w /path/to/dirsearch/db/openredirectwordlist.txt -e *"}')"

3. Gobuster https://github.com/OJ/gobuster

Setup:

$ go get github.com/OJ/gobuster

Usage:

$ gobuster dir -u https://mysite.com/path/to/folder -c 'session=123456' -t 50 -w common-files.txt -x .php,.html

4. wfuzz https://github.com/xmendez/wfuzz/

Setup:

$ pip install wfuzz

Usage( :

$ wfuzz -w raft-large-directories.txt -- sc 200,403,302 http://testphp.vulnweb.com/FUZZ

5. Burp Intruder

Screenshot Tools:

• Regardez les en-têtes pour voir quelles options de sécurité sont en place, par exemple rechercher la présence de X-XSS-Protection : ou X-Frame-Options : deny.

• Savoir quelles sont les mesures de sécurité en place signifie que vous connaissez vos limites.

1. Aquatone https://github.com/michenriksen/aquatone

Setup:

$ go get -u github.com/michenriksen/aquatone

Usage:

$ cat hosts.txt | aquatone -out ~/aquatone/example.com

2. Eyewitness: https://github.com/FortyNorthSecurity/EyeWitness

Setup:

$ git clone https://github.com/FortyNorthSecurity/EyeWitness.git

Naviguer dans le répertoire de configuration

Lancer le script setup.sh

Usage:

$ ./EyeWitness -f urls.txt -- web


$ ./EyeWitness -x urls.xml -- timeout 8 -- headless

3. Webscreenshot: https://github.com/maaaaz/webscreenshot

Setup:

$ apt-get update && apt-get install phantomjs


$ pip install webscreenshot

Usage:

$ python webscreenshot.py -i list.txt -v


Une fois cela fait, nous utilisons un outil appelé epg-prep (https://www.npmjs.com/package/epg-prep) pour créer des vignettes ; pour ce faire, il suffit de lancer : epg-prep uber.com

Cela nous permettra de visualiser les images créées à l'aide de la galerie photo express.

Dans une dernière étape, utilisez le script de la galerie expresse en bas de ce billet et enregistrez-le sous votre nom.js. Il vous suffit de modifier le nom du dossier dans le script :

app.use('/photos', Gallery('uber.com', options)) ; le nom du dossier dans ce cas est fixé à uber.com mais selon la cible que vous regardez, il peut être différent.

Une fois que vous avez fait cela, vous pouvez simplement lancer le script en utilisant le nœud yourname.js.

Cela créera un serveur web à l'écoute sur le port 3000 avec un point d'extrémité appelé /photos.

Pour y accéder, il vous suffit de taper : http://yourserverip:3000/photos pour avoir un bel aperçu des sous-domaines que vous avez énumérés

System Tools

$ apt update && apt upgrade


$ curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -


$ apt install -y git wget python python-pip phantomjs xvfb screen slurm gem phantomjs imagemagick graphicsmagick nodejs

Requirements for WebScreenshot

$ pip install webscreenshot


$ pip install selenium

Requirements for express-photo-gallery

$ sudo npm install -g npm


$ npm install express-photo-gallery


$ npm install express


$ npm install -g epg-prep

express-photo-gallery Script

JavaScript

var express = require('express');
var app = express();
var Gallery = require('express-photo-gallery');
var options = {
title: 'My Awesome Photo Gallery'
};
app.use('/photos', Gallery('uber.com', options));
app.listen(3000);


Check CMS

1. Extension du navigateur Wappalyzer

2. Builtwith - https://builtwith.com/

3. Retire.js pour l'ancienne bibliothèque JS

WAF

Attention aux WAFs, vous pouvez utiliser WafW00f pour cela

https://github.com/sandrogauci/wafw00f

Utilisation populaire de Google Dorks (trouver les sites web de Bug Bounty)

site:.eu responsible disclosure

inurl:index.php?id=

site:.nl bug bounty

“index of” inurl:wp-content/ (Identify Wordpress Website)

inurl:”q=user/password” (for finding drupal cms )

Voici une liste de dorks intéréssantes pour du recon


Pour chercher des infos dans du code :

site:codepad.co “company”

site:scribd.com “keyword”

site:npmjs.com “keyword”

site:npm.runkit.com “keyword”

site:jsdelivr.net “keyword”

site:codepen.io “keyword”

site:codeshare.io “keyword”

site:sharecode.io “keyword”

site:gitter.im “keyword”

site:bitbucket.org “keyword”

site:*.atlassian.net “keyword”

site:gitlab “keyword”

site:replt.it “keyword”


Pour trouver des outils ou des infos :

site:libraries.io “keyword”

site:ycombinator.com “keyword”

site:coggle.it “keyword”

site:papaly.com “keyword”

site:prezi.com “keyword”



Moteur de recherche :

site:google.com “keyword”


informations sensibles / breach : 

site:pastebin.com “keyword”

site:trello.com “keyword”

site:productforums..google.com “keyword”


Wordlists(dictionnaires)/Payloads

raft-large-words.txt, https://github.com/danielmiessler/SecLists

contentdiscoveryall.txt de jhaddix :

https://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10

all.txt de jhaddix— https://gist.github.com/jhaddix/f64c97d0863a78454e44c2f7119c2a6a

PayloadAllTheThings — https://github.com/swisskyrepo/PayloadsAllTheThings

XSS Payloads- http://www.xss-payloads.com/

XSS Payloads — https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt

SQL Injection Payloads — https://github.com/trietptm/SQL-Injection-Payloads

Google-Dorks Payloads — https://gist.github.com/clarketm/919457847cece7ce40323dc217623054

Extraction de vhosts

Web Tool — https://pentest-tools.com/information-gathering/find-virtual-hosts

Virtual host scanner — https://github.com/jobertabma/virtual-host-discovery

git clone https://github.com/jobertabma/virtual-host-discovery.git

ruby scan.rb — ip=192.168.1.101 — host=domain.tld

Port Scan

Analyser chaque adresse IP individuelle associée à ses sous-domaines et enregistrer le résultat dans un fichier

Recherchez tout service fonctionnant sur des ports inhabituels ou tout service fonctionnant sur des ports par défaut qui pourraient être vulnérables (FTP, SSH, etc.). Recherchez les informations sur les versions des services en cours d'exécution afin de déterminer si un service est obsolète et potentiellement vulnérable

1. Masscan : https://github.com/robertdavidgraham/masscan

Il s'agit d'un scanner de port à l'échelle d'Internet. Il peut scanner l'ensemble de l'Internet en moins de 6 minutes, en transmettant 10 millions de paquets par seconde, à partir d'une seule machine.

Setup:

$ sudo apt-get install git gcc make libpcap-dev


$ git clone https://github.com/robertdavidgraham/masscan


$ cd masscan


$ make -j8

Cela place le programme dans le sous-répertoire masscan/bin. Vous devrez le copier manuellement dans quelque chose comme /usr/local/bin si vous voulez l'installer ailleurs sur le système.

Usage:

Script shell pour exécuter "dig

- Parce que Masscan ne prend en compte que les adresses IP, et non les noms DNS

- Utilisez-le pour exécuter Masscan sur un domaine de nom ou une plage d'IP

#!/bin/bash
strip=$(echo $1|sed 's/https\?:\/\///')
echo ""
echo "##################################################"
host $strip
echo "##################################################"
echo ""
masscan -p1-65535 $(dig +short $strip|grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b"|head -1) -- max-rate 1000 |& tee $strip_scan
Usage: masscan -p1-65535 -iL $TARGET_LIST -- max-rate 10000 -oG $TARGET_OUTPUT
# masscan -p80,8000-8100 10.0.0.0/8
# masscan 10.0.0.0/8 -p80 -- banners -- source-ip 192.168.1.200

1. Nmap: https://nmap.org/book/man.html

Github pour du Recon

- Github est extrêmement utile pour trouver des informations sensibles concernant les cibles. Les clés d'accès, les mots de passe, les terminaisons ouvertes, les seaux s3, les fichiers de sauvegarde, etc. peuvent être trouvés sur les dépôts publics de GitHub.

Les éléments ci-dessous peuvent être recherchés lors d'une première évaluation générale (extraits de l'edoverflow) :

– API et key. (Obtenez d'autres points endpoints et trouvez les clés API).

– token

– secret

– TODO

– password

– vulnerable 😜

– http:// & https://

Ensuite, je me concentrerai sur les termes qui me font sourire lorsque les développeurs mettent la pagaille :

– CSRF

– random

– hash

– MD5, SHA-1, SHA-2, etc.

– HMAC

Github Recon Tools

1. gitrob: https://github.com/michenriksen/gitrob

Gitrob est un outil permettant de retrouver des fichiers potentiellement sensibles poussés vers des dépôts publics sur Github. Gitrob clone les dépôts appartenant à un utilisateur ou à une organisation jusqu'à une profondeur configurable, puis il passe en revue l'historique des logs et les fichiers de drapeau qui correspondent aux signatures de fichiers potentiellement sensibles. Les résultats seront présentés par le biais d'une interface web pour faciliter la navigation et l'analyse.

Setup:

$ go get github.com/michenriksen/gitrob

Usage:

$ gitrob [options] target [target2] ... [targetN]

1. shhgit — https://github.com/eth0izzle/shhgit

– Shhgit finds secrets and sensitive files across GitHub code and Gists committed in near real time by listening to the GitHub Events API.

Setup:

$ go get github.com/eth0izzle/shhgit

Usage:

Pour le configurer, consultez la page github.

Contrairement à d'autres outils, vous n'avez pas besoin de passer des cibles avec shhgit. Il suffit de lancer $ shhgit pour commencer à regarder les commits de GitHub et trouver des secrets ou des fichiers sensibles correspondant aux 120 signatures incluses.

Vous pouvez également renoncer aux signatures et utiliser shhgit avec une requête de recherche, par exemple pour trouver toutes les clés AWS que vous pourriez utiliser

$ shhgit -- search-query AWS_ACCESS_KEY_ID=AKIA

2. Trufflehog: https://github.com/dxa4481/truffleHog

Recherche dans les dépôts de git à la recherche de codes et de clés grâce aux dev flemmards ou mal organisés, en creusant profondément dans l'histoire des commit.

Setup:

$ pip install truffleHog

Usage:

$ truffleHog -- regex -- entropy=False https://github.com/dxa4481/truffleHog.git

3. git-all-secrets — https://github.com/anshumanbh/git-all-secrets

Il clone les github repo public/privé d'un org et d'un utilisateur appartenant à org et les scanne.

Il clone les gist appartenant à org et les utilisateurs de org.

Setup:

$ git clone https://github.com/anshumanbh/git-all-secrets.git

Usage:

$ docker run -- rm -it abhartiya/tools_gitallsecrets -- help


$ docker run -it abhartiya/tools_gitallsecrets -token=<> -org=<>

4. gitGraber https://github.com/hisxo/gitGraber

surveille GitHub pour rechercher et trouver des données sensibles en temps réel pour différents services en ligne tels que Google, Amazon, Paypal, Github, Mailgun, Facebook, Twitter, Heroku, Stripe.

Setup:

$ git clone https://github.com/hisxo/gitGraber.git


$ cd gitGraber


$ pip3 install -r requirements.txt

Usage:

$ python3 gitGraber.py -k wordlists/keywords.txt -q "uber" -s

Nous recommandons de créer un cron qui exécutera le script régulièrement :

*/15 * * * * cd /BugBounty/gitGraber/ && /usr/bin/python3 gitGraber.py -k wordlists/keywords.txt -q "uber" -s >/dev/null 2>&1

Le faire manuellement

Un rapide "Gratipay GitHub" de Google devrait renvoyer la page org de Gratipay sur GitHub. Ensuite, je vais vérifier quels repos appartiennent réellement à l'org et lesquels sont forkés. Vous pouvez le faire en sélectionnant le menu déroulant Type : sur le côté droit de la page. Réglez le sur Sources.

Maintenant, je vais jeter un coup d'oeil aux différentes langues dans lesquelles les projets sont écrits.

Mon langage préféré est le Python, donc je vais peut-être commencer à me concentrer sur les projets Python, mais pour la reconnaissance, je vais surtout prendre note des différents langages.

Ensuite, je commencerai à utiliser la barre de recherche GitHub pour rechercher des mots clés spécifiques.

org:gratipay hmac

Il y a 4 sections principales à consulter ici.

La section "Repositories" est idéale pour les projets dédiés au mot-clé. Par exemple, si le mot-clé est "gestionnaire de mots de passe", je pourrais trouver qu'ils sont en train de construire un gestionnaire de mots de passe.

Le code est le plus important. Vous pouvez rechercher les lignes de code classiques qui causent des vulnérabilités de sécurité dans toute l'organisation.

Les commits ne sont généralement pas mon domaine préféré à examiner manuellement, mais si je vois une faible quantité, je peux y jeter un coup d'œil rapide.

C'est le deuxième plus gros problème et il vous aidera tous dans votre reconnaissance. C'est la mine d'or.

Les entreprises partagent tellement d'informations sur leurs infrastructures dans les discussions et les débats sur les enjeux. Cherchez les domaines et sous-domaines dans ces billets.

Chris : "Oh, salut John. Nous avons oublié d'ajouter ce certificat à ce domaine : vuln.example.com".

noté

• “company.com” “dev”

• “dev.company.com”

• “company.com” API_key

• “company.com” password

• “api.company.com” authorization

• others

Lire tous les fichiers JS

Parfois, les fichiers Javascript contiennent des informations sensibles, notamment divers secrets ou des jetons codés en dur. Il est toujours utile d'examiner les fichiers JS manuellement.

Trouvez les éléments suivants en Javascript.

- AWS ou autres services Clés d'accès

- Les bacs AWS S3 ou autres buckets de stockage de données avec des autorisations de lecture/écriture.

- Ouvrir les endpoints de la base de données sql de sauvegarde

- endpoints des services internes.

JS File Parsing

1. JSParser: https://github.com/nahamsec/JSParser

Setup:

$ git clone https://github.com/nahamsec/JSParser.git

$ apt install libcurl4-openssl-dev libssl-dev

$ pip3 install -r requirements.txt


$ python setup.py install

Usage:

Run handler.py and then visit http://localhost:8008.

$ python handler.py

1. LinkFinder: https://github.com/GerbenJavado/LinkFinder

LinkFinder est un script python écrit pour découvrir les points terminaux et leurs paramètres dans des fichiers JavaScript

Setup:

$ git clone https://github.com/GerbenJavado/LinkFinder.git


$ cd LinkFinder


$ pip3 install -r requirements.txt


$ python setup.py install

Usage:

- L'utilisation la plus élémentaire pour trouver des points terminaux dans un fichier JavaScript en ligne et pour sortir les résultats en HTML sur results.html :

$ python linkfinder.py -i https://example.com/1.js -o results.html

• CLI/STDOUT (n'utilise pas jsbeautifier, ce qui le rend très rapide) :

$ python linkfinder.py -i https://example.com/1.js -o cli

• Analyser un domaine entier et ses fichiers JS :

$ python linkfinder.py -i https://example.com -d

- Burp input (sélectionner dans la cible les fichiers que vous voulez enregistrer, clic droit, Enregistrer les éléments sélectionnés, alimenter ce fichier en entrée) :

$ python linkfinder.py -i bpython linkfinder.py -i 'Desktop/*.js' -r ^/api/ -o results.html

- Enumération d'un dossier entier pour les fichiers JavaScript, tout en recherchant les points terminaux commençant par /api/ et en enregistrant finalement les résultats dans results.html :

$ python linkfinder.py -i 'Desktop/*.js' -r ^/api/ -o results.html

1. getJS https://github.com/003random/getJS

Un outil pour obtenir rapidement toutes les sources/fichiers javascript

Setup:

$ go get github.com/003random/getJS

Usage:

$ cat domains.txt | getJS |tojson

Pour alimenter les urls à partir d'un fichier, utilisez :

$ getJS -input=domains.txt

2. InputScanner https://github.com/zseano/InputScanner


Un outil conçu pour scraper une liste d'URL et gratter les noms d'entrée (id si aucun nom n'est trouvé). Cet outil permet également de récupérer les urls .js trouvées sur chaque page (pour des tests supplémentaires).

Setup:

Pour faire fonctionner PHP. Il est recommandé d'utiliser LAMP/XAMPP en local pour pouvoir exécuter le PHP depuis votre ordinateur. Vous pouvez prendre XAMPP ici :

https://www.apachefriends.org/index.html.

• Clone in /var/www

$ git clone https://github.com/zseano/InputScanner.git

Usage:

Maintenant que vous êtes prêt, il est temps de rassembler quelques URL à tester. Utilisez Burp Spider pour ramper.

Une fois que les scraper est terminé (ou que vous l'avez arrêtée), faites un clic droit sur l'hôte et cliquez sur "Copy Urls in this host".

Une fois copiées, collez-les dans urls.txt. Ouvrez maintenant payloads.txt et entrez les données que vous souhaitez injecter dans chaque paramètre (comme xss" xss' pour tester la réflexion des caractères " et ' sur les entrées.

Cela permettra d'automatiser la recherche de XSS). Ce script va injecter chaque charge utile dans chaque paramètre... donc plus il y a de charges utiles, plus vous enverrez de demandes.

Maintenant allez à l’url http://127.0.0.1/InputScanner/ et débutez votre scan

Une fois le scanner terminé, vous recevrez 4 sorties de fichiers txt (voir ci-dessous). Utilisez le BURP Intruder pour importer vos listes et les parcourir.

4 fichiers sont sortis dans le dossier /outputs/ : JS-output.txt, GET-output.txt, POSTHost-output.txt, POSTData-output.txt.

GET-output.txt est un fichier qui peut être facilement importé dans une attaque d'intrus BURP (en utilisant le type Spider).


Définissez la position dans l'en-tête (GET §val§ HTTP/1.0) et lancez l'attaque. Veillez à jouer avec les paramètres et décochez "URL-encode these characters", qui se trouve dans l'onglet Payloads. Actuellement, le script fera écho à l'url HOST, et je ne fais que la remplacer en masse dans un éditeur de texte tel que Sublime. (Remplacer par null). Vous êtes libre de modifier le script comme bon vous semble.

JS-output.xt contient une liste d'urls .js qui se trouvent sur chaque page. Le format se trouve à l'adresse suivante : https://www.example.com/. Vous pouvez donc le charger facilement dans JS-Scan (un autre outil que j'ai mis au point) et vous saurez où chaque fichier .js a été trouvé au fur et à mesure qu'il sera gratté.

Le fichier POSTHost-output.txt contient une liste d'url HOST (comme https://www.google.com/) qui est utilisée pour l'attaque de l'intrus par le burp "Pitchfork". Utilisez ce fichier avec le fichier POSTData-output.txt. Définissez le type d'attaque sur "Pitch fork" et définissez une position dans l'en-tête (comme pour l'attaque par sniper ci-dessus), et une autre en bas de la requête (les données envoyées par la poste). Assurez-vous de définir un Content-Length etc.


POSTData-output.txt contient les données postales. (param1=xss"&param2=xss"&param3=xss")

3. JS-Scan https://github.com/zseano/JS-Scan

Un outil conçu pour scraper une liste de fichiers .js et en extraire des urls, ainsi que des informations juteuses.

Setup:

1. Install un serveur LAMP/XAMPP.

2. InputScanner pour scraper les fichiers .js

3. Cloner le repo:

$ git clone https://github.com/zseano/JS-Scan.git

Usage:

Importer le fichier JS-output.txt dans cette interface — http://127.0.0.1/JS-Scan/

WaybackUrl

En cherchant les pages web cibles dans waybackmachine, on peut trouver les éléments suivants.

Des fichiers JS anciens et abandonnés.

Anciens terminaux d'API.

Des terminaux CDN abandonnés.

Sous-domaines abandonnés.

Endpoint de développement et de staging avec des infos juteuses dans les commentaires du code source.

Si vous obtenez 403 sur une page, vous pouvez également rechercher ces pages 403 dans wayback machine parfois, vous les trouverez exposées avec des informations utiles.

1. waybackurls — https://github.com/tomnomnom/waybackurls

Récupérez toutes les URL que la machine à remonter le temps connaît pour un domaine.

Setup:

$ go get github.com/tomnomnom/waybackurls

Usage:

$ cat domains.txt | waybackurls > urls

1. waybackunifier https://github.com/mhmdiaa/waybackunifier

WaybackUnifier vous permet de voir à quoi ressemble un fichier en agrégeant toutes les versions de ce fichier, et en créant une version unifiée qui contient toutes les lignes qu'il contient.

Setup:

$ go get github.com/mhmdiaa/waybackunifier

Usage:

Syntax:

-concurrency int
Nombre de requêtes à effectuer en parallèle (par défaut 1)

-output string
Fichier dans lequel enregistrer les résultats (default “output.txt”)

-sub string
une liste de sous-chaînes séparées par des virgules à rechercher dans les instantanés (les instantanés ne seront pris en compte que s'ils contiennent l'une d'entre elles)(default “Disallow,disallow”)

-url string

URL to unify versions of (without protocol prefix) (default “site.com/robots.txt”)

Webmap


Beaucoup de cartes mentales du web :

https://pentester.land/cheatsheets/2019/03/25/compilation-of-recon-workflows.html

Outils de takeover de sous domaines

1. SubOver https://github.com/Ice3man543/SubOver

Un puissant outil de prise de contrôle des sous-domaines

Setup:

$ go get github.com/Ice3man543/SubOver

Usage:

$ ./SubOver -l subdomains.txt

2. subjack https://github.com/haccer/subjack

Subjack est un outil de reprise de sous-domaines écrit en Go conçu pour scanner simultanément une liste de sous-domaines et identifier ceux qui peuvent être détournés

Subjack vérifiera également les sous-domaines attachés à des domaines qui n'existent pas (NXDOMAIN) et qui sont disponibles pour être enregistrés. Plus besoin de creuser

Setup:

$ go get github.com/haccer/subjack

Usage:

$ ./subjack -w subdomains.txt -t 100 -timeout 30 -o results.txt -ssl

3. TakeOver-v1 https://github.com/samhaxr/TakeOver-v1

Il donne au CNAME l'ensemble des sous-domaines d'un fichier

Setup:

$ git clone https://github.com/samhaxr/TakeOver-v1.git

Usage:

$ ./takeover.sh subdomain.txt

4. subzy https://github.com/LukaSikic/subzy

• Outil de reprise de sous-domaine qui fonctionne sur la base de la correspondance des empreintes digitales de réponse de can-i-take-over-xyz

Setup:

$ go get -u -v github.com/lukasikic/subzy


$ go install -v github.com/lukasikic/subzy

Usage:

Liste des sous-domaines

$ ./subzy -targets list.txt


Sous-domaines uniques ou peu nombreux

$ ./subzy -target test.google.com


$ ./subzy -target test.google.com,https://test.yahoo.com

Autres outils sympas

1. Parameth https://github.com/maK-/parameth

Cet outil peut être utilisé pour découvrir de manière brute les paramètres GET et POST

Souvent, lorsque vous fouillez un répertoire pour trouver des fichiers communs, vous pouvez identifier des scripts (par exemple test.php) qui semblent avoir besoin d'un paramètre inconnu. Cela peut, espérons-le, vous aider à les trouver.

Setup:

$ git clone https://github.com/maK-/parameth.git


$ virtualenv venv


$ . ./venv/bin/activate


$ pip install -u -r requirements.txt

Usage:

./parameth.py -u http://example.com/test.php

2. Arjun https://github.com/s0md3v/Arjun

Suite de découverte de paramètres HTTP.

Setup:

$ git clone https://github.com/s0md3v/Arjun.git

Usage:

Numérisation d'une seule URL

Pour trouver les paramètres GET, vous pouvez simplement faire :

$ python3 arjun.py -u https://api.example.com/endpoint -- get

De même, utilisez - post pour POST et - json pour rechercher les paramètres JSON.

Numérisation de plusieurs URL

Une liste d'URLs stockées dans un fichier peut être testée en utilisant l'option - urls comme suit

$ python3 arjun.py -- urls targets.txt -- get

3. fuxploitder https://github.com/almandin/fuxploider

Scanner et outil d'exploitation des vulnérabilités de téléchargement de fichiers.

Setup:

$ git clone https://github.com/almandin/fuxploider.git


$ cd fuxploider


$ pip3 install -r requirements.txt

Usage:

Pour obtenir une liste des options de base et des interrupteurs, utilisez :

$ python3 fuxploider.py -h

Exemple de base :

$ python3 fuxploider.py -- url https://awesomeFileUploadService.com -- not-regex "wrong file type"

4. Syborg — https://github.com/MilindPurswani/Syborg

Recenseur récursif de sous-domaines du DNS avec système de contournement des impasses

Setup:

Clonez le repo en utilisant la commande git clone comme suit :

$ git clone https://github.com/MilindPurswani/Syborg.git

Résoudre les dépendances :

$ pip3 install -r requirements.txt

Usage:

$ python3 syborg.py yahoo.com

Parfois, il est également possible que Syborg atteigne une utilisation élevée du processeur et cela peut vous coûter cher si vous essayez d'utiliser cet outil sur votre VPS. Par conséquent, pour limiter cette utilisation, un autre utilitaire appelé Cpulimit

$ cpulimit -l 50 -p $(pgrep python3)

Cet outil peut être téléchargé comme suit :

$ sudo apt install cpulimit

5. dnsgen https://github.com/ProjectAnte/dnsgen

Génère une combinaison de noms de domaine à partir des données fournies.

Les combinaisons sont créées sur la base d'une liste de mots. Les mots personnalisés sont extraits par exécution.

Setup:

$ pip3 install dnsgen

..or from GitHub:

$ git clone https://github.com/ProjectAnte/dnsgen


$ cd dnsgen


$ pip3 install -r requirements.txt


$ python3 setup.py install

Usage:

$ dnsgen domains.txt 


(domains.txt contient une liste des noms de domaine actifs)

Combinaisons avec massdns:

$ cat domains.txt | dnsgen -- | massdns -r /path/to/resolvers.txt -t A -o J -- flush 2>/dev/null

6. SSRFmap https://github.com/swisskyrepo/SSRFmap

Fuzzer automatique et outil d'exploitation du SSRF

SSRFmap prend un fichier de demande de rots en entrée et un paramètre à fuzz.

Setup:

$ git clone https://github.com/swisskyrepo/SSRFmap


$ cd SSRFmap/


$ pip3 install -r requirements.txt

Usage:

Il faut d'abord une requête avec un paramètre à fuzz, les requêtes Burp fonctionnent bien avec SSRFmap. Elles doivent ressembler à ce qui suit. D'autres exemples sont disponibles dans le dossier /data.

POST /ssrf HTTP/1.1
Host: 127.0.0.1:5000
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:62.0) Gecko/20100101 Firefox/62.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://mysimple.ssrf/
Content-Type: application/x-www-form-urlencoded
Content-Length: 31
Connection: close
Upgrade-Insecure-Requests: 1

url=https%3A%2F%2Fwww.google.fr

Utilisez le -m suivi du nom du module (séparé par un , si vous voulez lancer plusieurs modules).

# Lancez un scan de ports sur localhost et lisez les fichiers par défaut

$ python ssrfmap.py -r data/request.txt -p url -m readfiles,portscan

7. nip.io https://nip.io/

Un simple joker DNS pour toute adresse IP

Arrêtez de modifier votre fichier etc/hosts avec des mappages personnalisés de noms d'hôtes et d'adresses IP.

nip.io vous permet de le faire en associant n'importe quelle adresse IP à un nom d'hôte en utilisant les formats suivants :

– 10.0.0.1.nip.io maps to 10.0.0.1

– 192–168–1–250.nip.io maps to 192.168.1.250

8. CORS Scanner https://github.com/chenjj/CORScanner

scanner de vulnérabilités de mauvaise configuration du CORS

Setup:

$ git clone https://github.com/chenjj/CORScanner.git

Installer des dépendances

$ sudo pip install -r requirements.txt

Usage:

– Pour vérifier les mauvaises configurations CORS d'un domaine spécifique :

$ python cors_scan.py -u example.com

– Pour vérifier les mauvaises configurations CORS d'une URL spécifique :

$ python cors_scan.py -u http://example.com/restapi

– Pour vérifier la mauvaise configuration de la SCRO avec des en-têtes spécifiques :

$ python cors_scan.py -u example.com -d "Cookie: test"

– Pour vérifier les mauvaises configurations CORS de plusieurs domaines/URL :

$ python cors_scan.py -i top_100_domains.txt -t 100

9. Blazy https://github.com/s0md3v/Blazy

Blazy est un "login bruteforcer" moderne qui teste également le CSRF, le Clickjacking, le Cloudflare et le WAF .

Setup:

$ git clone https://github.com/UltimateHackers/Blazy


$ cd Blazy


$ pip install -r requirements.txt

Usage:

$ python blazy.py

10. XSStrike https://github.com/s0md3v/XSStrike

– Most advanced XSS scanner.

Setup:

$ git clone https://github.com/s0md3v/XSStrike.git

Usage:

Scan a single URL

Option: -u or — url

Testez une seule page web qui utilise la méthode GET.


$ python xsstrike.py -u "http://example.com/search.php?q=query"

Supplying POST data

$ python xsstrike.py -u "http://example.com/search.php" -- data "q=query"

11. Commix — https://github.com/commixproject/commix

Outil automatisé d'injection et d'exploitation des commandes All-in-One OS.

Setup:

$ git clone https://github.com/commixproject/commix.git commix

Usage:

https://github.com/commixproject/commix/wiki/Usage-Examples

$ python commix.py -- url="http://192.168.178.58/DVWA-1.0.8/vulnerabilities/exec/#" -- data="ip=127.0.0.1&Submit=submit" -- cookie="security=medium; PHPSESSID=nq30op434117mo7o2oe5bl7is4"

12. Bolt https://github.com/s0md3v/Bolt

Un stupide scanner CSRF

Setup:

$ git clone https://github.com/s0md3v/Bolt.git

Usage:

Scanner un site web à la recherche de CSRF en utilisant Bolt est aussi simple que de faire

$ python3 bolt.py -u https://github.com -l 2

1. bass https://github.com/Abss0x7tbh/bass

Bass vous attrape ces "résolveurs supplémentaires" qui vous manquent lorsque vous effectuez le recensement du DNS actif. Ajoutez entre 100 et 6 000 résolveurs à votre fichier "resolver.txt".

Setup:

$ git clone https://github.com/Abss0x7tbh/bass.git


$ cd bass


$ pip3 install -r requirements.txt

Usage:

$ python3 bass.py -d target.com -o output/file/for/final_resolver_list.txt

1. meg — https://github.com/tomnomnom/meg

meg est un outil qui permet de récupérer de nombreuses URL tout en étant "gentil" avec les serveurs.

Il peut être utilisé pour aller chercher plusieurs chemins pour de nombreux hôtes ; il suffit d'aller chercher un chemin pour tous les hôtes avant de passer au chemin suivant et de le répéter.

Setup:

$ go get -u github.com/tomnomnom/meg

Usage:

Etant donné un fichier plein de chemins :

/robots.txt

/.well-known/security.txt

/package.json

Et un fichier rempli d'hôtes (avec un protocole) :

http://example.com

https://example.com

http://example.net

meg demandera chaque chemin pour chaque hôte :

▶ meg — verbose paths hosts

$ meg <endpoint> <host>


$ meg / https://edoverflow.com

Cette dernière commande demande le répertoire de premier niveau pour https://edoverflow.com (https://edoverflow.com/). Il est important de noter que la plupart des protocoles sont spécifiés ; meg ne préfixe pas automatiquement les hôtes. Si vous avez une liste de cibles sans protocole, assurez-vous de bien spécifier le fichier et d'ajouter le bon protocole.

$ sed 's#^#http://#g' list-of-hosts > output

Par défaut, meg stocke toutes les sorties dans un répertoire out/, mais si vous souhaitez inclure un répertoire de sortie dédié, il suffit d'ajouter le répertoire de sortie à votre commande comme suit :

$ meg / https://edoverflow.com out-edoverflow/

Supposons que nous souhaitions identifier des fichiers spécifiques qui pourraient soit nous aider dans notre ciblage d'une plateforme, soit constituer un véritable problème de sécurité en tant que tel s'ils sont exposés au public. Il suffit d'une liste d'endpoints (listes/php) et d'une série de cibles (targets-all). Pour ce processus, le stockage de toutes les pages qui renvoient un code d'état "200 OK" nous aidera à éliminer la plupart des bruits et des faux positifs (-s 200).

$ meg -s 200 lists/php targets-all/out-php/ 2> /dev/null

2. tojson https://github.com/tomnomnom/hacks/tree/master/tojson

Transformer les lignes de stdin en JSON.

Setup:

$ go get -u github.com/tomnomnom/hacks/tojson

Usage:

$ getJS -url=https://poc-server.com | tojson


$ ls -l | tojson

3. interlace https://github.com/codingo/Interlace

Transformez facilement les applications de ligne de commande à fil unique en une application rapide et multi-filière avec la prise en charge du CIDR et du glob.

Setup:

$ git clone https://github.com/codingo/Interlace.git


$ python3 setup.py install

Usage:

Supposons que nous devions exécuter Nikto (un scanner de base gratuit de vulnérabilité des serveurs web) sur une liste d'hôtes :

$ cat targets.txt

hackerone.com

bugcrowd.com

yahoo.com

google.com

$ interlace -tL ./targets.txt -threads 5 -c "nikto -- host _target_ > ./_target_-nikto.txt" -v

==============================================Interlace v1.2 by Michael Skelton (@codingo_)==============================================[13:06:16] [VERBOSE] [nikto — host yahoo.com > ./yahoo.com-nikto.txt] Added after processing[13:06:16] [VERBOSE] [nikto — host google.com > ./google.com-nikto.txt] Added after processing[13:06:16] [VERBOSE] [nikto — host hackerone.com > ./hackerone.com-nikto.txt] Added after processing[13:06:16] [VERBOSE] [nikto — host bugcrowd.com > ./bugcrowd.com-nikto.txt] Added after processing[13:06:16] [THREAD] [nikto — host google.com > ./google.com-nikto.txt] Added to Queue

Décomposons un peu la situation - voici la commande qui a été exécutée :

interlace -tL ./targets.txt -threads 5 -c “nikto — host _target_ > ./_target_-nikto.txt” -v

– L'entrelacement est le nom de l'outil.

– -tL ./targets.txt définit un fichier avec une liste d'hôtes.

– -threads 5 définit le nombre dethreads.

– -c doit être immédiatement suivie par la commande que vous voulez exécuter.

– “nikto — host _target_ > ./_target_-nikto.txt” est la commande réelle qui sera exécutée, notez que les instances de _target_ seront remplacées par chaque ligne dans le fichier ./targets.txt

– -v rend la réponse plus détaillée

Good Articles to Read

1. Subdomain Takeover by Patrik — https://0xpatrik.com/subdomain-takeover/, https://0xpatrik.com/takeover-proofs/

2. Subdomain Enumeration — https://0xpatrik.com/subdomain-enumeration-smarter/, https://0xpatrik.com/subdomain-enumeration-2019/

3. Can-I-take-over-xyz — https://github.com/EdOverflow/can-i-take-over-xyz

4. File Upload XSS — https://brutelogic.com.br/blog/file-upload-xss/

5. Serverless Toolkit for Pentesters — https://blog.ropnop.com/serverless-toolkit-for-pentesters/

6. Docker for Pentesters — https://blog.ropnop.com/docker-for-pentesters/

7. For coding — https://learnxinyminutes.com/

8. Android Security Lab Setup — https://medium.com/@ehsahil/basic-android-security-testing-lab-part-1-a2b87e667533

9. SSL Bypass — https://medium.com/@ved_wayal/hail-frida-the-universal-ssl-pinning-bypass-for-android-e9e1d733d29

10. Bypass Certificate Pinning — https://blog.it-securityguard.com/the-stony-path-of-android-%F0%9F%A4%96-bug-bounty-bypassing-certificate-pinning/

11. Burp macros and Session handling — https://digi.ninja/blog/burp_macros.php

12. Burp Extensions — https://blog.usejournal.com/bug-hunting-methodology-part-2-5579dac06150

13. JSON CSRF to form data attack — https://medium.com/@osamaavvan/json-csrf-to-formdata-attack-eb65272376a2

14. meg — https://edoverflow.com/2018/meg/

15. assetnote: https://github.com/tdr130/assetnote Push notifications for the new domain

16. interlace : https://medium.com/@hakluke/interlace-a-productivity-tool-for-pentesters-and-bug-hunters-automate-and-multithread-your-d18c81371d3d

17. http-desync-attacks-request-smuggling-reborn- https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn

Scripts

• the art of subdomain enumeration — https://github.com/appsecco/the-art-of-subdomain-enumeration

• Setup Bug Bounty tools : https://gist.github.com/LuD1161/66f30da6d8b6c1c05b9f6708525ea885

• ReconPi — https://github.com/x1mdev/ReconPi/tree/dev/v2.0

• TotalRecon — Insalls all the tools — https://github.com/vitalysim/totalrecon

• Auto Recon Bash Script — https://github.com/mehulpanchal007/venom

Recon My Way

1. Dénombrement des sous-domaines à l'aide de l'amass, de l'assetfinder, du subfind

$ amass enum -- passive -d <DOMAIN>


$ assetfinder -- subs-only <domain>


$ subfinder -d freelancer.com


$ subfinder -d <domain> -recursive -silent -t 200 -v -o <outfile>

2. Utilisez la liste de mots CommonSpeak2 pour obtenir les permutations probables des sous-domaines ci-dessus.

https://github.com/assetnote/commonspeak2-wordlists

Pour générer les possibilités, vous pouvez utiliser ce simple extrait de Python :

scope = '<DOMAIN>'
wordlist = open('./commonspeak2.txt').read().split('\n')

for word in wordlist:
    if not word.strip():
        continue
print('{}.{}\n'.format(word.strip(), scope))


3. Utilisez les massdns pour résoudre tous les domaines ci-dessus :

$ ./bin/massdns -r lists/resolvers.txt -t A domains.txt > results.txt


4. Pour obtenir les meilleurs resolvers.txt, utilisez l'outil bass :

$ python3 bass.py -d target.com -o output/file/for/final_resolver_list.txt


5. Utilisez dnsgen pour générer une combinaison de noms de domaine à partir de l'entrée fournie.

$ cat domains.txt | dnsgen -- | massdns -r /path/to/resolvers.txt -t A -o J -- flush 2>/dev/null


6.Port Scan Utilisation de masscan et nmap pour le scan de la version

Script shell pour exécuter "dig

– Parce que Masscan ne prend en compte que les adresses IP, et non les noms DNS

– Utilisez-le pour exécuter Masscan sur un nom de domaine ou une plage d'adresses IP

#!/bin/bash
strip=$(echo $1|sed 's/https\?:\/\///')
echo ""
echo "##################################################"
host $strip
echo "##################################################"
echo ""
masscan -p1-65535 $(dig +short $strip|grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b"|head -1) -- max-rate 1000 |& tee $strip_scan

ou

$ nmap -iL list.txt -Pn -n -sn -oG output.txt


$ masscan -iL output.txt -p 0-65535 -- max-rate 1000

ou lancez massscan + nmap en utilisant le script ci-dessous

$ wget https://raw.githubusercontent.com/PacktPublishing/Mastering-Kali-Linux-for-Advanced-Penetration-Testing-Third-Edition/master/Chapter03/massNmap.sh

nmap scan avec sortie dans un beau fichier xml !

$ sudo nmap -sS -T4 -sC -oA myreportname -- stylesheet https://raw.githubusercontent.com/honze-net/nmap-bootstrap-xsl/master/nmap-bootstrap.xsl -iL subdomain.txt

7. Faire de la reconnaissance github

8. Faites une capture d'écran en utilisant aquatone.

cat hosts.txt | aquatone -out ~/aquatone/example.com

9. Exécutez ffuz ou gobuster dans le répertoire bruteforce/content discovery sur un domaine/sous-domaine particulier

$ ffuf -w /path/to/wordlist -u https://target/FUZZ

10. Lire le fichier JS, obtenir les points terminaux, vérifier s'il y a un jeton/clé secret dans les fichiers JS.

11. Utilisez les waybackurls pour récupérer les anciens fichiers JS, et les fichiers 403.

– Générer une liste de mots en utilisant le wayback

$ curl -s "http://web.archive.org/cdx/search/cdx?url=hackerone.com/*&output=text&fl=original&collapse=urlkey" | sed 's/\//\n/g' | sort -u | grep -v 'svg\|.png\|.img\|.ttf\|http:\|:\|.eot\|woff\|ico\|css\|bootstrap\|wordpress\|.jpg\|.jpeg' > wordlist

or

$ curl -L http://xrl.us/installperlnix | bash


$ curl -s "http://web.archive.org/cdx/search/cdx?url=hackerone.com/*&output=text&fl=original&collapse=urlkey" | sed 's/\//\n/g' | sort -u | grep -v 'svg\|.png\|.img\|.ttf\|http:\|:\|.eot\|woff\|ico\|css\|bootstrap\|wordpress\|.jpg\|.jpeg' | perl -pe 's/\%(\w\w)/chr hex $1/ge' > wordlist.txt

12. Une seule ligne pour importer la liste complète des sous-domaines dans la suite Burp pour un balayage automatisé !

$ cat <file-name> | parallel -j 200 curl -L -o /dev/null {} -x 127.0.0.1:8080 -k -s




Cet article a été traduit de l’anglais avec quelques précisions et modifications


Tu as bien aimé l'article ou tu as mal aux yeux :

Le lien du PDF

Article écrit par :
Mikael Monjour
Data et Automatisation