noptrix/httpgrepScanner HTTP(S) asynchrone qui recherche des chaînes ou des expressions régulières dans les corps de réponse et les en-têtes, sur des hôtes, ports, plages CIDR et vhosts à certificat TLS.
Un outil Python asynchrone et rapide qui scanne des serveurs HTTP(S) et recherche des chaînes de caractères ou des motifs regex dans les corps et les en-têtes des réponses HTTP.
Il accepte des hôtes uniques, des URLs, des plages CIDR, des plages d'adresses IP ou des fichiers ; scanne plusieurs ports par cible (un seul, listes séparées par des virgules ou plages, détection automatique TLS vs simple par port) ; peut extraire et scanner les (v)hôtes basés sur le nom directement depuis les certificats TLS ; diffuse les correspondances en direct sur le terminal ; et peut écrire les résultats dans des fichiers journaux texte, CSV ou JSONL.
Il est conçu pour les grands scans : un cœur asynchrone pilote des milliers de connexions concurrentes, une vérification TCP préalable ignore les ports morts à moindre coût, des délais d'attente par hôte et globaux évitent qu'il ne reste bloqué sur des cibles lentes/mortes, et une exécution interrompue peut être reprise.
termios et la gestion des signaux Unix d'asyncio)pip install -r requirements.txt (ou pip install httpx)uvloop (boucle d'événements plus rapide), aiodns (dns non bloquant pour -r), h2 (HTTP/2 pour -2), httpx[socks] / socksio (proxies SOCKS)httpgrep est un script unique autonome - exécutez simplement ./httpgrep.py.
$ httpgrep -H
__ __ __
/ /_ / /_/ /_____ ____ _________ ____
/ __ \/ __/ __/ __ \/ __ `/ ___/ _ \/ __ \
/ / / / /_/ /_/ /_/ / /_/ / / / __/ /_/ /
/_/ /_/\__/\__/ .___/\__, /_/ \___/ .___/
/_/ /____/ /_/
--== [ by nullsecurity.net ] ==--
usage
httpgrep -h <arg> -s <arg> [opts] | <misc>
target options
-h <hosts|file> - hôte unique/url ou plage hôte-/cidr ou fichier contenant
des hôtes ou fichier contenant des URLs, ex. : foobar.net,
192.168.0.1-192.168.0.254, 192.168.0.0/24, /tmp/hosts.txt
une liste d'hôtes séparée par des virgules fonctionne
aussi, ex. : 1.2.3.4,foo.net,10.0.0.0/24
NOTE : les hôtes peuvent aussi contenir ':<ports>' en ligne
de commande ou dans le fichier, où <ports> est un port
unique, une liste séparée par des virgules ou une plage,
ex. : foo.net:8080, foo.net:80,443, 10.0.0.1:1-1024
-p <ports|file> - port(s) auxquels se connecter : port unique, liste séparée
par des virgules, plage, ou fichier avec une spécification
par ligne, ex. : 80, 80,443,8080, 8000-8100,
/tmp/ports.txt (défaut : 80, ou 443 quand -t est donné)
-t - force TLS/SSL sur tous les ports. par défaut le schéma est
auto-détecté par port (http simple, bascule vers TLS si le
port le parle)
-u <URI|file> - URI ou URIs séparées par des virgules ou fichier avec URIs
(une par ligne) dans lesquelles rechercher les chaînes
données, ex. : /foobar/, /foo.html, /admin,/login,
/tmp/paths.txt (défaut : /)
-r - affiche le nom reverse-dns (PTR) des IPv4 scannées comme
étiquette ; l'ip reste la cible du scan (pas de dérive de
périmètre). non bloquant avec le paquet aiodns
http options
-X <method> - méthode de requête HTTP à utiliser, n'importe quelle casse
(défaut : get). utilisez '?' pour lister les méthodes
disponibles.
-a <user:pass> - identifiants d'authentification http (format : 'user:pass')
-U <UA> - définit un User-Agent personnalisé (défaut : dernier
ms edge, windows)
-A - utilise un user-agent aléatoire par requête
-R <headers> - définit des en-têtes personnalisés (format :
'foo=bar;lol=lulz;...')
-C <cookies> - définit des cookies (format : 'foo=bar;lol=lulz;...')
-F - ne suit pas les redirections HTTP
-L <num> - nombre maximal de redirections à suivre (défaut : 10 ;
ignoré avec -F)
-E - vérifie les certificats TLS/SSL (défaut : aucune
vérification)
-P <proxy> - utilise un proxy (format :
'[http|https|socks4|socks5]://host:port')
(socks nécessite le paquet 'httpx[socks]' / socksio)
-f <codes> - ne rapporte que les réponses avec les codes de statut HTTP
donnés, ex. : '200', '200,301,302'
-e <codes> - exclut les réponses avec les codes de statut HTTP donnés,
ex. : '404', '403,404,500'
-2 - essaie HTTP/2 (négocié par ALPN sur TLS, repli sur 1.1 ;
http simple reste en 1.1). nécessite le paquet 'h2'
search options
-s <str|file> - une chaîne/expression régulière unique ou plusieurs
chaînes/expressions régulières dans un fichier à trouver
dans les corps et en-têtes des réponses HTTP (voir -w),
ex. : 'tomcat 8', '/tmp/igot0daysforthese.txt'
-S <str|file> - inverse (grep -v) : supprime TOUTES les correspondances
d'une réponse si cette chaîne/expression régulière (ou
fichier) apparaît n'importe où dans son corps ou ses
en-têtes, ex. pour filtrer les pages d'erreur / 404
dynamiques
-w <where> - où rechercher : headers, body, ou headers,body
(défaut : headers,body)
-b <bytes> - nombre d'octets de contexte à afficher depuis une
correspondance dans le body (défaut : 64)
-m <size> - body maximal à lire + rechercher ; suffixe b/kb/mb, pas de
suffixe = kb, ex. : 512, 1mb, 262144b (défaut : 256kb)
-i - utilise une recherche insensible à la casse
-I - utilise une inversion insensible à la casse (pour -S)
scan options
-x <num> - nombre maximal de connexions concurrentes (async ;
défaut : 300). augmentez ulimit -n en conséquence pour des
valeurs très élevées
-c <seconds> - délai d'attente de lecture par hôte en secondes, plafonne
aussi le temps de lecture du body. la vérification TCP
préalable est plafonnée à 2s quoi qu'il arrive, donc les
hôtes filtrés/morts libèrent leur emplacement rapidement
(défaut : 3.0)
-G <seconds> - délai d'attente global : arrêt forcé de tout le scan après
N secondes (filet de sécurité contre tout blocage ;
défaut : aucun)
-y <num> - réessaie une sonde ayant échoué jusqu'à <num> fois
(défaut : 0). aide avec les hôtes instables à grande
échelle ; gardez-le petit
-1 - dès qu'un hôte a une correspondance, ignore ses sondes non
encore démarrées (au mieux ; les requêtes en vol se
terminent quand même, donc avec un -x élevé vous pouvez
encore voir quelques correspondances par hôte)
-z <size> - scanne les cibles dans un ordre aléatoire dans une fenêtre
à mémoire bornée de <size> ram (suffixe b/kb/mb/gb),
ex. : -z 1gb. évite que les énormes plages/fichiers
épuisent la mémoire
-Z <num> - plafonne la fenêtre -z à <num> cibles (défaut 2000000,
~267mo à ~140 octets chacune). plus = mélange plus large
sur les énormes plages, au prix de la ram et de la mise en
mémoire tampon au démarrage
-W - sauvegarde/reprise : sur ctrl+c écrit la progression dans
httpgrep.session ; relancez avec -W pour reprendre à
partir de là (sinon repart de zéro)
-T <0|1> - sonde aussi les (v)hôtes du certificat (CN + SAN) comme
requêtes supplémentaires en plus du scan direct. 0 = via
l'en-tête Host sur la même ip (dans le périmètre) ; 1 =
AUSSI par nom dns/SNI (peut sortir du périmètre).
nécessite TLS (url https, -t, ou un port *443).
output options
-l <file> - journalise les correspondances trouvées dans <file>.<fmt>
selon le format -O choisi (ex. : -l out -O csv,jsonl =>
out.csv, out.jsonl)
-O <formats> - format(s) de fichier journal, liste séparée par des
virgules : txt, csv, jsonl (défaut : txt ; utilisez '?'
pour lister). la sortie terminal reste toujours lisible
par un humain.
-v - verbeux : affiche chaque url au fur et à mesure de son
scan
-7 - échappe le non-ASCII dans la sortie terminal en \xNN,
afin qu'un corps de réponse hostile ne puisse pas corrompre
votre terminal (les journaux restent bruts)
misc options
-H - affiche l'aide
-V - affiche les informations de version
examples
# grep 'apache' dans les en-têtes et le body d'un hôte unique
$ httpgrep -h foobar.net -s apache
# scanne une plage CIDR sur le port 8080, recherche 'tomcat' dans le body
# uniquement
$ httpgrep -h 192.168.0.0/24 -p 8080 -s tomcat -w body
# scanne un hôte sur plusieurs ports et une plage de ports pour 'jenkins'
$ httpgrep -h 192.168.0.10 -p 80,443,8080,8000-8100 -s jenkins -i
# scanne une liste d'hôtes, fichier de chaînes de recherche, journalise les
# correspondances (-> /tmp/out.txt)
$ httpgrep -h /tmp/hosts.txt -s /tmp/strings.txt -x 200 -l /tmp/out
# grep 'admin' insensible à la casse sur plusieurs URIs via TLS
$ httpgrep -h foobar.net -t -u /admin,/login,/dashboard -s admin -i
# scanne une plage d'IPs, reverse DNS, ne rapporte que les réponses 200
$ httpgrep -h 10.0.0.1-10.0.0.254 -s 'powered by' -r -f 200
# recherche uniquement dans les en-têtes, ne suit pas les redirections,
# sortie verbeuse
$ httpgrep -h foobar.net -s 'X-Powered-By' -w headers -F -v
# grep 'admin', mais supprime les pages d'erreur dynamiques (inversion,
# insensible à la casse)
$ httpgrep -h 192.168.0.0/24 -s admin -i -S 'error|not found' -I
# via un proxy, UA personnalisé, recherche de chaînes de version
$ httpgrep -h /tmp/hosts.txt -s 'nginx/1\.' -P http://127.0.0.1:8080 -U 'curl/8.0'
# grand scan reprenable : ctrl+c sauvegarde l'état, relancez avec -W pour
# continuer ; plafonnez aussi toute l'exécution à 1 heure comme filet de
# sécurité contre les blocages
$ httpgrep -h 10.0.0.0/16 -p 80,443 -s admin -W -G 3600
Les correspondances sont affichées en direct, une par ligne :
[*] <url> | [vhost] | <status> | <type> | <match>
<url> - l'URL scannée (scheme://host:port/uri).<vhost> - présent avec -T (le (v)hôte du certificat essayé via l'en-tête Host) ou -r (le nom PTR de l'ip scannée) ; vide pour les scans directs.<status> - le code de statut de la réponse HTTP (après les redirections).<type> - body ou header.<match> - hit dans le body : une courte fenêtre représentée depuis la correspondance (-b octets) ; hit dans l'en-tête : nom: valeur.Le terminal affiche toujours cette forme lisible par un humain. Avec -l <base> les mêmes correspondances sont reflétées dans <base>.<fmt> pour chaque format -O - txt (ces lignes), csv (lignes url,vhost,status,type,match avec un en-tête), jsonl (un objet JSON par correspondance).
Lors d'un scan multi-cibles, une ligne de statut en direct est affichée (épinglée en bas sur un tty, en lignes simples quand la sortie est redirigée) :
[+] wait bitch, scanning: <targets> | <scanned>/<total> | <pct>% | <n> hits
<total> est le nombre de cibles (cidrs/plages calculés, non développés) ; <n> hits est le nombre cumulé de lignes de correspondance émises jusqu'ici.
noptrix
Vérifiez docs/LICENSE.
Nous soulignons par la présente que tout ce qui concerne le hacking sur nullsecurity.net n'est qu'à des fins éducatives. Nous ne sommes pas responsables des dommages. Vous êtes responsable de vos propres actions.