DivideAndScan exploit

##

![DivideAndScan](

**Divide~~Et Impera~~ And Scan (e unisci anche i risultati della scansione)**

![versione]( ![python]( ![codacy]( ![pypi]( ![docker](

NixOS![NixOS]( ![offsec.tools](

**D** ivide**A** nd**S** can è usato per automatizzare in modo efficiente la routine di scansione delle porte, suddividendola in 3 fasi:

1. Scoprire le porte aperte per un insieme di target.

2. Eseguire Nmap individualmente per ogni target con version grabbing e azioni NSE.

3. Unire i risultati in un singolo report Nmap (diversi formati disponibili).

Per la 1ª fase si intende utilizzare uno _scanner di porte veloce_ *, il cui output viene analizzato e memorizzato in un database a file singolo (TinyDB). Successivamente, durante la 2ª fase vengono avviate scansioni Nmap individuali per ogni target con il suo set di porte aperte (il multiprocessing è supportato) in base ai dati del database. Infine, nella 3ª fase gli output Nmap separati vengono uniti in un unico report in diversi formati (XML / HTML / testo semplice / grepable) con nMap_Merger. La parte di visualizzazione è fornita da DrawNmap.

* Impegni di penetration test / red teaming con un ampio scopo da enumerare.

* Wargames di cybersecurity / laboratori CTF di addestramento.

> **DICHIARAZIONE DI NON RESPONSABILITÀ.** Tutte le informazioni contenute in questo repository sono fornite solo a scopo educativo e di ricerca. L'autore non è responsabile per qualsiasi uso illecito di questo strumento.

![come-funziona.png](

Per _dividere e scansionare_ con successo dobbiamo procurarci dei buoni strumenti di scansione delle porte (negli esempi seguenti le release di GitHub vengono scaricate tramite eget).

📑 **Nota:** se non hai voglia di sporcarti le mani con le dipendenze sul tuo sistema operativo host, passa direttamente alla parte Docker.

wget -O masscan-master.zip

eget -t 2.0.1 -a amd64 RustScan/RustScan --to /tmp/rustscan.deb

sudo dpkg -i /tmp/rustscan.deb && rm /tmp/rustscan.deb

sudo wget -O /root/.rustscan.toml

sudo eget -s linux/amd64 projectdiscovery/naabu --to /opt/naabu

sudo ln -sv /opt/naabu/naabu /usr/local/bin/naabu

sudo eget -a NimScan elddy/NimScan --to /opt/nimscan

sudo ln -sv /opt/nimscan/nimscan /usr/local/bin/nimscan

sudo eget -s linux/amd64 v-byte-cpu/sx --to /opt/sx

sudo eget -s linux/amd64 projectdiscovery/dnsx --to /opt/pd

sudo ln -sv /opt/pd/dnsx /usr/local/bin/dnsx

DivideAndScan è disponibile su PyPI come `divideandscan`, anche se consiglio di installarlo da GitHub con pipx per avere sempre la versione all'avanguardia:

~$ pipx install -f "git+

C'è anche una release impacchettata con shiv (anche se di grandi dimensioni):

# shiv -e das.divideandscan:main -o das.pyz divideandscan

~$ wget && chmod +x das.pyz

Per scopi di debug puoi configurare un ambiente di sviluppo con poetry:

~$ git clone --recurse-submodules

📑 **Nota:** DivideAndScan usa sudo per eseguire tutti gli scanner di porte, quindi chiederà la password quando vengono invocati i comandi di scansione.

![dockeri.co](

Puoi eseguire DivideAndScan in un container Docker nel modo seguente:

~$ docker run --rm -it --name das -v ~/.das:/root/.das -v `pwd`:/app -p 8050:8050 snovvcrash/divideandscan

Poiché lo strumento richiede alcuni dati di input e produce alcuni dati di output, dovresti specificare la tua directory di lavoro corrente come punto di mount su `/app` all'interno del container. Inoltre, pubblicare la porta 8050 sull'host permette di accedere all'app Dash utilizzata per la visualizzazione dei report Nmap.

Potresti voler impostare un alias per accorciare il comando base:

~$ alias das='docker run --rm -it --name das -v ~/.das:/root/.das -v `pwd`:/app -p 8050:8050 snovvcrash/divideandscan'

![come-usare.png](

Fornisci al modulo `add` un comando per uno scanner di porte veloce per scoprire porte aperte in un intervallo desiderato. ⚠️ **Attenzione:** per favore, assicurati di capire cosa stai facendo, perché quasi tutti gli strumenti di scansione delle porte possono danneggiare il sistema sottoposto a test se usati impropriamente. root@kitploit:~

# Nmap, il flag -v è sempre richiesto per un parsing corretto!

~$ das add nmap '-v -n -Pn -e eth0 --min-rate 1000 -T4 -iL hosts.txt -p1-65535 --open'

~$ das add masscan '--rate 1000 -iL hosts.txt -p1-65535 --open'

~$ das add rustscan '-b 1000 -t 2000 -u 5000 -a hosts.txt -r 1-65535 -g --no-config'

~$ das add naabu '-rate 1000 -iL hosts.txt -p - -silent -s s'

~$ das add nimscan '192.168.1.0/24 -vi -p:1-65535 -f:500'

~$ sudo sx arp -i eth0 192.168.1.0/24 --json | tee arp.cache

~$ das add sx 'tcp syn -a arp.cache -i eth0 --rate 1000/s 192.168.1.0/24 -p 445,3389'

Quando il modulo inizia il suo lavoro, viene creata una directory `~/.das/db` dove verranno inseriti il file del database e i risultati grezzi della scansione al termine della routine del modulo.

Avvia scansioni Nmap mirate con il modulo `scan`. Puoi regolare la superficie di scansione con l'opzione `-hosts` o `-ports`: root@kitploit:~

~$ das scan -hosts 192.168.1.0/24,10.10.13.37 -oA report1

~$ das scan -ports 22,80,443,445 -oA report2

Per avviare Nmap simultaneamente in più processi, specifica l'opzione `-parallel` e imposta il numero di worker con l'opzione `-proc` (se non viene fornito alcun valore, verrà impostato automaticamente al numero di processori della macchina): root@kitploit:~

~$ das scan -hosts all -oA report -parallel [-proc 4]

Il formato di output viene selezionato con le opzioni `-oX`, `-oN`, `-oG` e `-oA` rispettivamente per formati XML+HTML, testo semplice, grepable e tutti i formati. Quando il modulo completa il suo lavoro, viene creata una directory `~/.das/nmap_ ` contenente i report grezzi di scansione Nmap. Inoltre, puoi ispezionare il contenuto del database con l'opzione `-show` prima di avviare effettivamente le scansioni: root@kitploit:~

Per generare un report indipendentemente dal modulo `scan`, dovresti usare il modulo `report`. Cercherà i report grezzi di scansione Nmap nella directory `~/.das/nmap_ ` e li elaborerà e unirà in base all'opzione `-hosts` o `-ports`: root@kitploit:~

~$ das report -hosts 192.168.1.0/24,10.10.13.37 -oA report1

~$ das report -hosts hosts.txt -oA report1

~$ das report -ports 22,80,443,445 -oA report2

~$ das report -ports ports.txt -oA report2

📑 **Nota:** tieni presente che il modulo `report` **non** cerca nel DB quando elabora le opzioni `-hosts` o `-ports`, ma cerca direttamente i report Nmap grezzi nella directory `~/.das/nmap_ `; ciò significa che il valore dell'argomento `-hosts 127.0.0.1` verrà risolto con successo solo se esistono file `~/.das/nmap_ /127-0-0-1.*`, e il valore dell'argomento `-ports 80` verrà risolto con successo solo se esistono file `~/.das/nmap_ /port80.*`.

Enumeriamo le porte aperte per tutte le macchine attive su Hack The Box.

1. Aggiungi le mappature "host ⇄ porte aperte" al database con Masscan. A scopo dimostrativo escluderò l'intervallo di porte dinamico per evitare cose inutili usando `-p1-49151`. Nel secondo screenshot sto rivedendo i risultati della scansione per host e per porte:

~$ das -db htb add -rm masscan '-e tun0 --rate 1000 -iL hosts.txt -p1-49151 --open'

![esempio-1.png](

![esempio-2.png](

2. Avvia processi Nmap per ogni target per enumerare solo le porte che ci interessano (le porte aperte). Nel secondo screenshot sto facendo la stessa cosa ma avviando i processi Nmap simultaneamente:

~$ das -db htb scan -hosts all -oA report

![esempio-3.png](

~$ das -db htb scan -hosts all -oA report -nmap '-Pn -sVC -O' -parallel

![esempio-4.png](

3. Di conseguenza ora abbiamo un report singolo in tutti i formati Nmap familiari (testo semplice, grepable, XML) oltre a un bel report HTML.

![esempio-5.png](

Puoi abbinare il tuo scanner di porte preferito a DivideAndScan implementando un singolo metodo **parse** per il suo output in `das/parsers/DUMMY_SCANNER.py` (vedi esempio per masscan):

from das.parsers import IAddPortscanOutput

class AddPortscanOutput(IAddPortscanOutput):

"""Classe figlia per elaborare l'output di DUMMY_SCANNER."""

Parser dell'output grezzo di DUMMY_SCANNER.

:return: una coppia di valori (nome file output grezzo della scansione porte, numero di host aggiunti al DB)

# Implementazione del parser per DUMMY_SCANNER

usage: das [-h] [-db DB] {db,add,scan,dns,report,parse,draw,tree,help} ...

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

| ________ .__ .__ .___ _____ .____________ |

| \______ \ |__|__ _|__| __| _/____ / _ \ ____ __| _/ _____/ ____ _____ ____ |

| | | \| \ \/ / |/ __ |/ __ \ / /_\ \ / \ / __ |\_____ \_/ ___\\__ \ / \ |

| | ` \ |\ /| / /_/ \ ___// | \ | \/ /_/ |/ \ \___ / __ \| | \ |

| /_______ /__| \_/ |__\____ |\___ >____|__ /___| /\____ /_______ /\___ >____ /___| / |

| \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ |

| {@snovvcrash} { {vX.Y.Z} |

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

{db,add,scan,dns,report,parse,draw,tree,help}

db utilità per manipolazioni manuali del DB

add esegue una scansione completa delle porte e aggiunge l'output al DB

scan esegue scansioni Nmap mirate contro host e porte dal DB

dns mappa i nomi di dominio da un file di input agli indirizzi IP corrispondenti dal DB

report unisce output Nmap separati in un unico report (

parse analizza i report Nmap XML grezzi per nome del servizio e stampa le voci nel formato {servizio}://{host}:{porta}

draw visualizza i report Nmap XML (

tree mostra il contenuto della directory ~/.das/ usando tree

help mostra la finestra di aiuto integrata --help di uno scanner di porte selezionato

-h, --help mostra questo messaggio di aiuto ed esce

-db DB nome del DB con cui lavorare

Psst, ehi amico... Vuoi fare un po' di p0r7 5c4nn1n6 organizzato?

* ~~Aggiungere parser perprojectdiscovery/naabu~~

* ~~Memorizzare gli hostname (se presenti) accanto ai loro valori IP~~

* ~~Aggiungere opzione`ffuf` per automatizzare il fuzzing delle directory web~~ (aggiunto modulo `parse`)