robertdavidgraham/masscanScansionatore di porte TCP, emette pacchetti SYN in modo asincrono, scansione dell'intera Internet in meno di 5 minuti.
Questo è uno scanner di porte su scala Internet. Può scansionare l'intera Internet in meno di 5 minuti, trasmettendo 10 milioni di pacchetti al secondo, da una singola macchina.
Il suo utilizzo (parametri, output) è simile a nmap, il più famoso scanner di porte. In caso di dubbio, prova una di quelle funzionalità -- sono supportate le funzionalità per la scansione estesa di molte macchine, mentre non lo sono le scansioni approfondite di singole macchine.
Internamente, utilizza trasmissione asincrona, simile a scanner di porte come scanrand, unicornscan e ZMap. È più flessibile, consentendo range arbitrari di porte e indirizzi.
NOTA: masscan utilizza il proprio stack TCP/IP ad hoc. Qualsiasi cosa diversa da semplici scansioni di porte può causare conflitto con lo stack TCP/IP locale. Ciò significa che devi usare l'opzione --src-ip per eseguire da un indirizzo IP diverso, oppure usare --src-port per configurare quali porte sorgente usa masscan, e poi configurare anche il firewall interno (come pf o iptables) per isolare quelle porte dal resto del sistema operativo.
Questo strumento è gratuito, ma considera di contribuire economicamente al suo sviluppo: Indirizzo del portafoglio Bitcoin: 1MASSCANaHUiyTtR3bJ2sLGuMw5kDBaj4T
Su Debian/Ubuntu, si procede più o meno come segue. Non ha realmente altre dipendenze oltre a un compilatore C (come gcc o clang).
sudo apt-get --assume-yes install git make gcc
git clone https://github.com/robertdavidgraham/masscan
cd masscan
make
Questo mette il programma nella sottodirectory masscan/bin. Per installarlo (su Linux) esegui:
make install
Il sorgente consiste in molti piccoli file, quindi la compilazione è molto più veloce usando la build multi-thread. Questo richiede più di 2 GB su un Raspberry Pi (e si rompe), quindi potresti usare un numero più piccolo, come -j4 piuttosto che tutti i thread possibili.
make -j
Mentre Linux è la piattaforma target principale, il codice funziona bene su molti altri sistemi (Windows, macOS, ecc.). Ecco alcune informazioni aggiuntive sulla compilazione:
makemakegmakecc src/*.c -o bin/masscanSu macOS, i binari x86 sembrano funzionare altrettanto velocemente sotto emulazione ARM.
L'utilizzo è simile a nmap. Per scansionare un segmento di rete per alcune porte:
# masscan -p80,8000-8100 10.0.0.0/8 2603:3001:2d00:da00::/112
Questo farà:
10.x.x.x e la sottorete 2603:3001:2d00:da00::x<stdout> che può essere reindirizzato su un filePer vedere l'elenco completo delle opzioni, usa la funzionalità --echo. Questa scarica la configurazione corrente ed esce. Questo output può essere usato come input nel programma:
# masscan -p80,8000-8100 10.0.0.0/8 2603:3001:2d00:da00::/112 --echo > xxx.conf
# masscan -c xxx.conf --rate 1000
Masscan può fare più che semplicemente rilevare se le porte sono aperte. Può anche completare la connessione TCP e l'interazione con l'applicazione su quella porta per ottenere semplici informazioni "banner".
Masscan supporta il controllo banner sui seguenti protocolli:
Il problema è che masscan contiene il proprio stack TCP/IP separato dal sistema su cui lo esegui. Quando il sistema locale riceve un SYN-ACK dal target sondato, risponde con un pacchetto RST che uccide la connessione prima che masscan possa catturare il banner.
Il modo più semplice per prevenirlo è assegnare a masscan un indirizzo IP separato. Ciò assomiglia a uno dei seguenti esempi:
# masscan 10.0.0.0/8 -p80 --banners --source-ip 192.168.1.200
# masscan 2a00:1450:4007:810::/112 -p80 --banners --source-ip 2603:3001:2d00:da00:91d7:b54:b498:859d
L'indirizzo che scegli deve essere sulla sottorete locale e non altrimenti usato da un altro sistema. Masscan ti avvertirà che hai commesso un errore, ma potresti aver compromesso le comunicazioni dell'altra macchina per diversi minuti, quindi fai attenzione.
In alcuni casi, come WiFi, ciò non è possibile. In quei casi, puoi mettere un firewall sulla porta che masscan usa. Questo impedisce allo stack TCP/IP locale di vedere il pacchetto, ma masscan lo vede comunque poiché bypassa lo stack locale. Per Linux, ciò assomiglia a:
# iptables -A INPUT -p tcp --dport 61000 -j DROP
# masscan 10.0.0.0/8 -p80 --banners --source-port 61000
Probabilmente vorrai scegliere porte che non entrino in conflitto con le porte che Linux potrebbe altrimenti scegliere come porte sorgente. Puoi vedere il range che Linux usa, e riconfigurarlo, guardando nel file:
/proc/sys/net/ipv4/ip_local_port_range
Sull'ultima versione di Kali Linux (Agosto 2018), quel range è da 32768 a 60999, quindi dovresti scegliere porte al di sotto di 32768 o da 61000 in su.
Impostare una regola iptables dura solo fino al prossimo riavvio. Devi cercare come salvare la configurazione in base alla tua distribuzione, ad esempio usando iptables-save e/o iptables-persistent.
Su Mac OS X e BSD, ci sono passaggi simili. Per scoprire i range da evitare, usa un comando come il seguente:
# sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last
Su FreeBSD e MacOS più vecchi, usa un comando ipfw:
# sudo ipfw add 1 deny tcp from any to any 40000 in
# masscan 10.0.0.0/8 -p80 --banners --source-port 40000
Su MacOS più recenti e OpenBSD, usa l'utilità di filtraggio pacchetti pf. Modifica il file /etc/pf.conf per aggiungere una riga come la seguente:
block in proto tcp from any to any port 40000:40015
Quindi per abilitare il firewall, esegui il comando:
# pfctl -E
Se il firewall è già in esecuzione, riavvia o ricarica le regole con il seguente comando:
# pfctl -f /etc/pf.conf
Windows non risponde con pacchetti RST, quindi nessuna di queste tecniche è necessaria. Tuttavia, masscan è ancora progettato per funzionare al meglio usando il proprio indirizzo IP, quindi dovresti eseguirlo in questo modo quando possibile, anche quando non è strettamente necessario.
La stessa cosa è necessaria per altri controlli, come il controllo --heartbleed, che è solo una forma di controllo banner.
Sebbene utile per reti più piccole e interne, il programma è realmente progettato pensando all'intera Internet. Potrebbe assomigliare a questo:
# masscan 0.0.0.0/0 -p0-65535
Scansionare l'intera Internet è sbagliato. Per un motivo, parti di Internet reagiscono male alla scansione. Per un altro, alcuni siti tracciano le scansioni e ti aggiungono a una lista di blocco, il che ti farà essere bloccato da parti utili di Internet. Pertanto, vuoi escludere molti range. Per mettere in lista nera o escludere range, vuoi usare la seguente sintassi:
# masscan 0.0.0.0/0 -p0-65535 --excludefile exclude.txt
Questo stampa semplicemente i risultati sulla riga di comando. Probabilmente vuoi salvarli su un file invece. Pertanto, vuoi qualcosa come:
# masscan 0.0.0.0/0 -p0-65535 -oX scan.xml
Ma questo va solo alla velocità predefinita di 100 pacchetti/secondo, che impiegherà un'eternità per scansionare Internet. Devi accelerarlo come segue:
# masscan 0.0.0.0/0 -p0-65535 --max-rate 100000
Questo aumenta la velocità a 100.000 pacchetti/secondo, che scansionerà l'intera Internet (escluse le esclusioni) in circa 10 ore per porta (o 655.360 ore se si scansionano tutte le porte).
La cosa da notare su questa riga di comando è che tutte queste sono opzioni compatibili con nmap. Inoltre, opzioni "invisibili" compatibili con nmap vengono impostate automaticamente: -sS -Pn -n --randomize-hosts --send-eth. Allo stesso modo, il formato del file XML è ispirato a nmap. Ci sono, ovviamente, molte differenze, perché la natura asincrona del programma porta a un approccio fondamentalmente diverso al problema.
La riga di comando sopra è un po' macchinosa. Invece di mettere tutto sulla riga di comando, può essere memorizzata in un file. Le impostazioni sopra sarebbero simili a:
# My Scan
rate = 100000.00
output-format = xml
output-status = all
output-filename = scan.xml
ports = 0-65535
range = 0.0.0.0-255.255.255.255
excludefile = exclude.txt
Per usare questo file di configurazione, usa -c:
# masscan -c myscan.conf
Questo rende anche le cose più facili quando ripeti una scansione.
Per impostazione predefinita, masscan carica prima il file di configurazione /etc/masscan/masscan.conf. Eventuali parametri di configurazione successivi sovrascrivono quanto presente in questo file di configurazione predefinito. È lì che metto il mio parametro "excludefile" in modo da non dimenticarlo mai. Funziona automaticamente.
Per impostazione predefinita, masscan produce file di testo piuttosto grandi, ma è facile convertirli in qualsiasi altro formato. Ci sono cinque formati di output supportati:
xml: basta usare il parametro -oX <filename>. Oppure, usa i parametri --output-format xml e --output-filename <filename>.
binary: questo è il formato nativo di masscan. Produce file molto più piccoli in modo che quando scansiono Internet il mio disco non si riempia. Devono però essere analizzati. L'opzione da riga di comando --readscan legge i file binari di scansione. Usare --readscan con l'opzione -oX produce una versione XML del file dei risultati.
grepable: questa è un'implementazione dell'output Nmap -oG che può essere facilmente analizzata da strumenti da riga di comando. Basta usare il parametro -oG <filename>. Oppure, usa i parametri --output-format grepable e --output-filename <filename>.
json: salva i risultati in formato JSON. Basta usare il parametro -oJ <filename>. Oppure, usa i parametri --output-format json e .
Dove ragionevole, ogni sforzo è stato fatto per rendere il programma familiare agli utenti di nmap, anche se è fondamentalmente diverso. Masscan è ottimizzato per la scansione su larga scala di molte macchine, mentre nmap è progettato per la scansione intensiva di una singola macchina o di un piccolo range.
Due importanti differenze sono:
-p <porte>nmap può usare (come 10.0.0-255.0-255).Puoi pensare a masscan come avente le seguenti impostazioni permanentemente abilitate:
-sS: esegue solo scansione SYN (attualmente, cambierà in futuro)-Pn: non esegue ping agli host prima, fondamentale per l'operazione asincrona-n: non avviene risoluzione DNS--randomize-hosts: scansione completamente randomizzata, sempre, non puoi cambiarlo--send-eth: invia usando raw libpcapSe vuoi un elenco di impostazioni aggiuntive compatibili con nmap, usa il seguente comando:
# masscan --nmap
Questo programma emette pacchetti molto velocemente. Su Windows, o da macchine virtuali, può raggiungere 300.000 pacchetti/secondo. Su Linux (senza virtualizzazione) farà 1,6 milioni di pacchetti al secondo. È abbastanza veloce da fondere la maggior parte delle reti.
Nota che fonderà solo la tua rete. Randomizza gli indirizzi IP target in modo da non sovraccaricare alcuna rete remota.
Per impostazione predefinita, la velocità è impostata a 100 pacchetti/secondo. Per aumentare la velocità a un milione usa qualcosa come --rate 1000000.
Quando si scansiona l'Internet IPv4, si scansioneranno molte sottoreti, quindi anche se c'è un'alta velocità di pacchetti in uscita, ogni sottorete target riceverà una piccola velocità di pacchetti in arrivo.
Tuttavia, con la scansione IPv6, tenderai a concentrarti su una singola sottorete target con miliardi di indirizzi. Pertanto, il tuo comportamento predefinito sovraccaricherà la rete target. Le reti spesso collassano sotto il carico che masscan può generare.
Questa sezione descrive i principali aspetti di progettazione del programma.
Il file main.c contiene la funzione main(), come ci si aspetta. Contiene anche le funzioni transmit_thread() e receive_thread(). Queste funzioni sono state deliberatamente appiattite e ampiamente commentate in modo da poter leggere la progettazione del programma semplicemente scorrendo riga per riga ciascuna di esse.
Questo è un design asincrono. In altre parole, sta a nmap come il web-server nginx sta a Apache. Ha thread di trasmissione e ricezione separati che sono in gran parte indipendenti l'uno dall'altro. È lo stesso tipo di design presente in scanrand, unicornscan e ZMap.
Poiché è asincrono, funziona alla massima velocità consentita dalla trasmissione sottostante dei pacchetti.
Una differenza chiave tra Masscan e altri scanner è il modo in cui randomizza i target.
Il principio fondamentale è avere una singola variabile indice che parte da zero e viene incrementata di uno per ogni sonda. In codice C, questo è espresso come:
for (i = 0; i < range; i++) {
scan(i);
}
Dobbiamo tradurre l'indice in un indirizzo IP. Diciamo che vuoi scansionare tutti gli indirizzi IP "privati". Sarebbe la tabella di range come:
192.168.0.0/16
10.0.0.0/8
172.16.0.0/12
In questo esempio, i primi 64k indici vengono aggiunti a 192.168.x.x per formare l'indirizzo target. Poi, i successivi 16 milioni vengono aggiunti a 10.x.x.x. Gli indici rimanenti nel range vengono applicati a 172.16.x.x.
In questo esempio, abbiamo solo tre range. Quando si scansiona l'intera Internet, in pratica abbiamo più di 100 range. Questo perché devi mettere in lista nera o escludere molti sotto-range. Questo suddivide il range desiderato in centinaia di range più piccoli.
Questo porta a una delle parti più lente del codice. Trasmettiamo 10 milioni di pacchetti al secondo e dobbiamo convertire una variabile indice in un indirizzo IP per ogni singola sonda. Risolviamo questo facendo una "ricerca binaria" in una piccola quantità di memoria. A questa velocità di pacchetti, le efficienze della cache iniziano a dominare sulle efficienze algoritmiche. Ci sono molte tecniche più efficienti in teoria, ma tutte richiedono così tanta memoria da essere più lente in pratica.
Chiamiamo la funzione che traduce da un indice a un indirizzo IP la funzione pick(). In uso, assomiglia a:
for (i = 0; i < range; i++) {
ip = pick(addresses, i);
scan(ip);
}
Masscan supporta non solo range di indirizzi IP, ma anche range di porte. Ciò significa che dobbiamo selezionare dalla variabile indice sia un indirizzo IP che una porta. Questo è abbastanza semplice:
range = ip_count * port_count;
for (i = 0; i < range; i++) {
ip = pick(addresses, i / port_count);
port = pick(ports, i % port_count);
scan(ip, port);
}
Questo porta a un'altra parte costosa del codice. Le istruzioni di divisione/modulo sono circa 90 cicli di clock, o 30 nanosecondi, su CPU x86. Quando si trasmette a una velocità di 10 milioni di pacchetti/secondo, abbiamo solo 100 nanosecondi per pacchetto. Non vedo modo di ottimizzare meglio. Fortunatamente, due di queste operazioni possono essere eseguite simultaneamente, quindi eseguirne due, come mostrato sopra, non costa più di una.
Ci sono in realtà alcune facili ottimizzazioni per i problemi di prestazioni sopra, ma tutte si basano su i++, il fatto che la variabile indice aumenta uno per uno durante la scansione. In realtà, dobbiamo randomizzare questa variabile. Dobbiamo randomizzare l'ordine degli indirizzi IP che scansioniamo o colpiremo violentemente le reti target che non sono costruite per questo livello di velocità. Dobbiamo distribuire il nostro traffico uniformemente sul target.
Il modo in cui randomizziamo è semplicemente crittografando la variabile indice. Per definizione, la crittografia è casuale e crea una mappatura 1-a-1 tra la variabile indice originale e l'output. Ciò significa che mentre procediamo linearmente attraverso il range, gli indirizzi IP di output sono completamente casuali. Nel codice, assomiglia a:
range = ip_count * port_count;
for (i = 0; i < range; i++) {
x = encrypt(i);
ip = pick(addresses, x / port_count);
port = pick(ports, x % port_count);
scan(ip, port);
}
Questo ha anche un costo importante. Poiché il range ha una dimensione imprevedibile invece di una bella potenza pari di 2, non possiamo usare tecniche binarie economiche come AND (&) e XOR (^). Invece, dobbiamo usare operazioni costose come MODULO (%). Nei miei benchmark attuali, ci vogliono 40 nanosecondi per crittografare la variabile.
Questa architettura permette molte funzionalità interessanti. Ad esempio, supporta gli "shard". Puoi impostare 5 macchine ciascuna che fa un quinto della scansione o range / shard_count. Gli shard possono essere più macchine, o semplicemente più adattatori di rete sulla stessa macchina, o anche (se vuoi) più indirizzi IP sorgente sullo stesso adattatore di rete.
Oppure, puoi usare un 'seme' o 'chiave' per la funzione di crittografia, in modo da ottenere un ordine diverso ogni volta che scansiona, come x = encrypt(seed, i).
Possiamo anche mettere in pausa la scansione uscendo dal programma, e semplicemente ricordare il valore corrente di i, e riavviarlo più tardi. Lo faccio spesso durante lo sviluppo. Vedo qualcosa che va storto nella mia scansione Internet, quindi premo per fermare la scansione, poi la riavvio dopo aver corretto il bug.
Un'altra funzionalità sono le ritrasmissioni/riprove. I pacchetti a volte vengono persi su Internet, quindi puoi inviare due pacchetti uno dopo l'altro. Tuttavia, qualcosa che perde un pacchetto potrebbe perdere anche il pacchetto immediatamente successivo. Pertanto, vuoi inviare la copia a circa 1 secondo di distanza. Questo è semplice. Abbiamo già una variabile 'rate', che è il numero di pacchetti al secondo a cui stiamo trasmettendo, quindi la funzione di ritrasmissione è semplicemente usare i + rate come indice. Uno di questi giorni farò uno studio su Internet, e differenzierò le ritrasmissioni "back-to-back", "1 secondo", "10 secondi", e "1 minuto" in questo modo per vedere se c'è qualche differenza in ciò che viene perso.
La tecnica asincrona è nota come soluzione al "problema c10k". Masscan è progettato per il livello successivo di scalabilità, il "problema C10M".
La soluzione C10M è bypassare il kernel. Ci sono tre bypass principali del kernel in Masscan:
Masscan può usare il driver PF_RING DNA. Questo driver trasferisce i pacchetti direttamente dalla memoria in modalità utente al driver di rete senza coinvolgimento del kernel. Ciò consente al software, anche con una CPU lenta, di trasmettere pacchetti alla velocità massima consentita dall'hardware. Se metti 8 schede di rete da 10 gbps in un computer, significa che potrebbe trasmettere a 100 milioni di pacchetti/secondo.
Masscan ha il proprio stack TCP integrato per catturare banner dalle connessioni TCP. Ciò significa che può supportare facilmente 10 milioni di connessioni TCP simultanee, supponendo ovviamente che il computer abbia abbastanza memoria.
Masscan non ha "mutex". I mutex moderni (noti anche come futex) sono per lo più in modalità utente, ma hanno due problemi. Il primo problema è che causano un rapido rimbalzo delle linee di cache tra le CPU. Il secondo è che quando c'è contesa, eseguono una chiamata di sistema nel kernel, che uccide le prestazioni. Un mutex nel percorso rapido di un programma limita severamente la scalabilità. Invece, Masscan usa "anelli" per sincronizzare le cose, ad esempio quando lo stack TCP in modalità utente nel thread di ricezione necessita di trasmettere un pacchetto senza interferire con il thread di trasmissione.
Windows e Mac non sono ottimizzati per la trasmissione di pacchetti e raggiungono solo circa 300.000 pacchetti al secondo, mentre Linux può arrivare a 1.500.000 pacchetti al secondo. Probabilmente è più veloce di quanto tu voglia comunque.
Viene offerta una ricompensa per le vulnerabilità, consulta il file VULNINFO.md per maggiori informazioni.
Questo progetto utilizza funzioni sicure come safe_strcpy() invece di funzioni non sicure come strcpy().
Questo progetto ha test di regressione automatici (make regress).
È stato fatto un grande sforzo per far sì che l'input/output assomigli a nmap, che chiunque effettui scansioni di porte conosce (o dovrebbe conoscere).
Masscan supporta IPv6, ma non esiste una modalità speciale, entrambi sono supportati contemporaneamente. (Non esiste l'opzione -6 -- è sempre disponibile).
In qualsiasi esempio di utilizzo di masscan, basta inserire un indirizzo IPv6 dove vedi un indirizzo IPv4. Puoi includere indirizzi IPv4 e IPv6 contemporaneamente nella stessa scansione. L'output include l'indirizzo appropriato nella stessa posizione, senza marcature speciali.
Ricorda solo che lo spazio degli indirizzi IPv6 è molto grande. Probabilmente non vorrai scansionare grandi intervalli, tranne forse i primi 64.000 indirizzi di una sottorete assegnati tramite DHCPv6.
Invece, probabilmente vorrai scansionare grandi elenchi di indirizzi memorizzati in un file (--include-file filename.txt) ottenuti da altre fonti. Come altrove, questo file può contenere elenchi sia di indirizzi IPv4 che IPv6. Il file di test che uso contiene 8 milioni di indirizzi. I file di queste dimensioni necessitano di un paio di secondi extra per essere letti all'avvio (masscan ordina gli indirizzi e rimuove i duplicati prima della scansione).
Ricorda che masscan ha il proprio stack di rete. Pertanto, la macchina locale su cui esegui masscan non deve avere IPv6 abilitato -- anche se la rete locale deve essere in grado di instradare pacchetti IPv6.
Per superare i 2 milioni di pacchetti al secondo, è necessaria una scheda Ethernet Intel a 10 Gbps e un driver speciale noto come "PF_RING ZC" di ntop. Masscan non necessita di essere ricompilato per utilizzare PF_RING. Per utilizzare PF_RING, è necessario compilare i seguenti componenti:
libpfring.so (installato in /usr/lib/libpfring.so)pf_ring.ko (il loro driver del kernel)ixgbe.ko (la loro versione del driver Ethernet Intel a 10 Gbps)Non è necessario compilare la loro versione di libpcap.so.
Quando Masscan rileva che un adattatore ha un nome come zc:enp1s0 invece di qualcosa come enp1s0, passerà automaticamente alla modalità PF_RING ZC.
Una discussione più dettagliata può essere trovata in PoC||GTFO 0x15.
Il progetto contiene un test unitario integrato:
$ make test
bin/masscan --selftest
selftest: success!
Questo testa molte parti complesse del codice. Dovresti farlo dopo la compilazione.
Per testare le prestazioni, esegui qualcosa di simile al seguente su un indirizzo usa e getta, per evitare di sovraccaricare il tuo router locale:
$ bin/masscan 0.0.0.0/4 -p80 --rate 100000000 --router-mac 66-55-44-33-22-11
Il fittizio --router-mac mantiene i pacchetti sui segmenti di rete locale in modo che non vadano su Internet.
Puoi anche testare in modalità 'offline', che mostra quanto velocemente il programma funziona senza il sovraccarico della trasmissione:
$ bin/masscan 0.0.0.0/4 -p80 --rate 100000000 --offline
Questo secondo benchmark mostra approssimativamente quanto velocemente il programma funzionerebbe se usasse PF_RING, che ha un sovraccarico quasi nullo.
A proposito, l'algoritmo di randomizzazione fa ampio uso di 'aritmetica intera', un'operazione cronicamente lenta sulle CPU. Le CPU moderne hanno raddoppiato la velocità con cui eseguono questo calcolo, rendendo masscan molto più veloce.
Questo strumento è stato creato da Robert Graham: email: [email protected] twitter: @ErrataRob
Copyright (c) 2013 Robert David Graham
This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, version 3 of the License.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License along with this program. If not, see https://www.gnu.org/licenses/.
--output-filename <filename>list: questo è un semplice elenco con una coppia host e porta per riga. Basta usare il parametro -oL <filename>. Oppure, usa i parametri --output-format list e --output-filename <filename>. Il formato è:
<port state> <protocol> <port number> <IP address> <POSIX timestamp>
open tcp 80 XXX.XXX.XXX.XXX 1390380064