Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
DivideAndScan — Teile die Ergebnisse eines vollständigen Portscans auf und verwende sie für gezielte Nmap-Durchläufe | Kitploit
Tools/GitHubGitHub/snovvcrash/divideandscan
SchwachstellenscannerNetzwerkkartierungPort-ScanningScripting & AutomatisierungPenetrationstests
GitHubsnovvcrash/divideandscan

DivideAndScan

Teile die Ergebnisse eines vollständigen Portscans auf und verwende sie für gezielte Nmap-Durchläufe

Repository anzeigen
33349vor 2 JahrenVon Kitploit geprüft

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

DivideAndScan

Divide Et Impera And Scan (und auch die Scan-Ergebnisse zusammenführen)

version python codacy pypi docker

Vorgestellte Projekte

NixOSNixOS

DivideAndScan wird verwendet, um die Port-Scanning-Routine effizient zu automatisieren, indem sie in 3 Phasen aufgeteilt wird:

  1. Offene Ports für eine Reihe von Zielen entdecken.
  2. Nmap individuell für jedes Ziel mit Versionserkennung und NSE-Aktionen ausführen.
  3. Die Ergebnisse in einem einzigen Nmap-Bericht zusammenführen (verschiedene Formate verfügbar).

Für die 1. Phase ist ein schneller Port-Scanner* vorgesehen, dessen Ausgabe geparst und in einer einzigen Datei-Datenbank (TinyDB) gespeichert wird. In der 2. Phase werden dann für jedes Ziel mit seinen offenen Ports individuelle Nmap-Scans gestartet (Multiprocessing wird unterstützt), basierend auf den Daten der Datenbank. Schließlich werden in der 3. Phase die einzelnen Nmap-Ausgaben mit nMap_Merger zu einem einzigen Bericht in verschiedenen Formaten (XML / HTML / einfacher Text / grepable) zusammengeführt. Die Visualisierung wird von DrawNmap bereitgestellt.

Mögliche Anwendungsfälle:

  • Pentest-Aufträge / Red Teaming mit einem großen zu enumerierenden Bereich.
  • Cybersicherheits-Kriegsspiele / Trainings-CTF-Labore.
  • OSCP-Zertifizierungsprüfung.

* Verfügbare Port-Scanner:

  • Nmap
  • Masscan
  • RustScan
  • Naabu
  • NimScan
  • sx

HAFTUNGSAUSSCHLUSS. Alle in diesem Repository enthaltenen Informationen dienen ausschließlich Bildungs- und Forschungszwecken. Der Autor ist nicht verantwortlich für jegliche illegale Nutzung dieses Tools.

So funktioniert's

how-it-works.png

Installation

Voraussetzungen

Um erfolgreich zu teilen und zu scannen, benötigen wir einige gute Port-Scanning-Tools (in den Beispielen unten werden GitHub-Releases über eget heruntergeladen).

📑 Hinweis: Wenn Sie keine Lust haben, sich mit Abhängigkeiten auf Ihrem Host-Betriebssystem herumzuschlagen, springen Sie zum Docker-Teil.

Nmap

root@kitploit:~
sudo apt install nmap xsltproc -y
sudo nmap --script-updatedb

Masscan

root@kitploit:~
pushd /tmp
wget https://github.com/ivre/masscan/archive/refs/heads/master.zip -O masscan-master.zip
unzip masscan-master.zip
cd masscan-master
make
sudo make install
popd && rm -rf /tmp/masscan-master*

RustScan

root@kitploit:~
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 https://gist.github.com/snovvcrash/8b85b900bd928493cd1ae33b2df318d8/raw/fe8628396616c4bf7a3e25f2c9d1acc2f36af0c0/rustscan-ports-top1000.toml -O /root/.rustscan.toml

Naabu

root@kitploit:~
sudo mkdir /opt/naabu
sudo eget -s linux/amd64 projectdiscovery/naabu --to /opt/naabu
sudo ln -sv /opt/naabu/naabu /usr/local/bin/naabu

NimScan

root@kitploit:~
sudo mkdir /opt/nimscan
sudo eget -a NimScan elddy/NimScan --to /opt/nimscan
sudo ln -sv /opt/nimscan/nimscan /usr/local/bin/nimscan

sx

root@kitploit:~
sudo mkdir /opt/sx
sudo eget -s linux/amd64 v-byte-cpu/sx --to /opt/sx
sudo ln -sv /opt/sx/sx /usr/local/bin/sx

dnsx

root@kitploit:~
sudo mkdir /opt/pd
sudo eget -s linux/amd64 projectdiscovery/dnsx --to /opt/pd
sudo ln -sv /opt/pd/dnsx /usr/local/bin/dnsx

Installation

DivideAndScan ist auf PyPI als divideandscan verfügbar, obwohl ich empfehle, es von GitHub mit pipx zu installieren, um immer die aktuellste Version zu haben:

root@kitploit:~
~$ pipx install -f "git+https://github.com/snovvcrash/DivideAndScan.git"
~$ das

Es gibt auch ein Release, das mit shiv gepackt ist (allerdings große Dateigröße):

root@kitploit:~
# shiv -e das.divideandscan:main -o das.pyz divideandscan
~$ wget https://github.com/snovvcrash/DivideAndScan/releases/latest/download/das.pyz && chmod +x das.pyz
~$ ./das.pyz

Für Debugging-Zwecke können Sie eine Entwicklungsumgebung mit poetry einrichten:

root@kitploit:~
~$ git clone --recurse-submodules https://github.com/snovvcrash/DivideAndScan
~$ cd DivideAndScan
~$ poetry install
~$ poetry run das

📑 Hinweis: DivideAndScan verwendet sudo, um alle Port-Scanner auszuführen. Daher wird bei der Ausführung von Scan-Befehlen das Passwort abgefragt.

Verwendung aus Docker

dockeri.co

Sie können DivideAndScan in einem Docker-Container wie folgt ausführen:

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

Da das Tool einige Eingabedaten benötigt und Ausgabedaten erzeugt, sollten Sie Ihr aktuelles Arbeitsverzeichnis als Mount-Punkt unter /app im Container angeben. Das Veröffentlichen von Port 8050 auf dem Host ermöglicht den Zugriff auf die Dash-App, die zur Visualisierung von Nmap-Berichten verwendet wird.

Sie können einen Alias setzen, um den Basisbefehl zu verkürzen:

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

Verwendung

how-to-use.png

1. Datenbank befüllen

2. Gezielte Scans

3 (Optional). Berichte zusammenführen

🔥 Beispiel 🔥

Lassen Sie uns offene Ports für alle aktiven Maschinen auf Hack The Box enumerieren.

  1. Fügen Sie der Datenbank die Zuordnungen "Host ⇄ offene Ports" mit Masscan hinzu. Zu Demonstrationszwecken werde ich den dynamischen Portbereich ausschließen, um unnötige Daten zu vermeiden, indem ich -p1-49151 verwende. Auf dem zweiten Screenshot sehe ich mir die Scan-Ergebnisse nach Hosts und nach Ports an:
root@kitploit:~
~$ das -db htb add -rm masscan '-e tun0 --rate 1000 -iL hosts.txt -p1-49151 --open'

example-1.png

root@kitploit:~
~$ das -db htb scan -hosts all -show
~$ das -db htb scan -ports all -show

example-2.png

  1. Starten Sie Nmap-Prozesse für jedes Ziel, um nur die Ports zu enumerieren, die uns interessieren (die offenen Ports). Auf dem zweiten Screenshot mache ich dasselbe, starte aber Nmap-Prozesse gleichzeitig:
root@kitploit:~
~$ das -db htb scan -hosts all -oA report

example-3.png

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

Bring Your Own Scanner!

Sie können Ihren Lieblings-Port-Scanner mit DivideAndScan kombinieren, indem Sie eine einzige parse-Methode für dessen Ausgabe in das/parsers/DUMMY_SCANNER.py implementieren (siehe Beispiel für masscan):

root@kitploit:~
from das.parsers import IAddPortscanOutput


class AddPortscanOutput(IAddPortscanOutput):
    """Child class for processing DUMMY_SCANNER output."""

    def parse(self):
        """
        DUMMY_SCANNER raw output parser.

        :return: a pair of values (portscan raw output filename, number of hosts added to DB)
        :rtype: tuple
        """
        hosts = set()
        for line in self.portscan_raw:
            # DUMMY_SCANNER parser implementation
            pass

        return (self.portscan_out, len(hosts))

Hilfe

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

 -----------------------------------------------------------------------------------------------
|  ________  .__      .__    .___        _____              .____________                       |
|  \______ \ |__|__  _|__| __| _/____   /  _  \   ____    __| _/   _____/ ____ _____    ____    |
|   |    |  \|  \  \/ /  |/ __ |/ __ \ /  /_\  \ /    \  / __ |\_____  \_/ ___\\__  \  /    \   |
|   |    `   \  |\   /|  / /_/ \  ___//    |    \   |  \/ /_/ |/        \  \___ / __ \|   |  \  |
|  /_______  /__| \_/ |__\____ |\___  >____|__  /___|  /\____ /_______  /\___  >____  /___|  /  |
|          \/                 \/    \/        \/     \/      \/       \/     \/     \/     \/   |
|  {@snovvcrash}            {https://github.com/snovvcrash/DivideAndScan}             {vX.Y.Z}  |
 -----------------------------------------------------------------------------------------------

positional arguments:
  {db,add,scan,dns,report,parse,draw,tree,help}
    db                  utilities for manual DB manipulations
    add                 run a full port scan and add the output to DB
    scan                run targeted Nmap scans against hosts and ports from DB
    dns                 map domain names from an input file to corresponding IP addresses from the DB
    report              merge separate Nmap outputs into a single report (https://github.com/CBHue/nMap_Merger)
    parse               parse raw Nmap XML reports by service names and print entries in format {service}://{host}:{port}}
    draw                visualize Nmap XML reports (https://github.com/jor6PS/DrawNmap)
    tree                show contents of the ~/.das/ directory using tree
    help                show builtin --help dialog of a selected port scanner

options:
  -h, --help            show this help message and exit
  -db DB                DB name to work with

Psst, hey buddy... Wanna do some organized p0r7 5c4nn1n6?

ToDo

  • Add projectdiscovery/naabu parser
  • Add elddy/NimScan parser
  • Add sx parser
  • Add ZMap parser
  • Store hostnames (if there're any) next to their IP values
  • Add fuff switch to automate web directory fuzzing (added parse module)
Tool herunterladen
offsec.tools
NixOSoffsec.tools

Geben Sie dem add-Modul einen Befehl für einen schnellen Port-Scanner, um offene Ports in einem gewünschten Bereich zu entdecken.

⚠️ Warnung: Bitte stellen Sie sicher, dass Sie verstehen, was Sie tun, da fast alle Port-Scanning-Tools das getestete System beschädigen können, wenn sie unsachgemäß verwendet werden.

root@kitploit:~
# Nmap, -v Flag ist für korrektes Parsen immer erforderlich!
~$ das add nmap '-v -n -Pn -e eth0 --min-rate 1000 -T4 -iL hosts.txt -p1-65535 --open'
# Masscan
~$ das add masscan '--rate 1000 -iL hosts.txt -p1-65535 --open'
# RustScan
~$ das add rustscan '-b 1000 -t 2000 -u 5000 -a hosts.txt -r 1-65535 -g --no-config'
# Naabu
~$ das add naabu '-rate 1000 -iL hosts.txt -p - -silent -s s'
# NimScan
~$ das add nimscan '192.168.1.0/24 -vi -p:1-65535 -f:500'
# sx
~$ 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'

Wenn das Modul seine Arbeit aufnimmt, wird ein Verzeichnis ~/.das/db erstellt, in dem die Datenbankdatei und die rohen Scan-Ergebnisse abgelegt werden, sobald die Modulroutine abgeschlossen ist.

Starten Sie gezielte Nmap-Scans mit dem scan-Modul. Sie können die Scanfläche entweder mit der Option -hosts oder -ports anpassen:

root@kitploit:~
# Nach Hosts scannen
~$ das scan -hosts all -oA report1
~$ das scan -hosts 192.168.1.0/24,10.10.13.37 -oA report1
~$ das scan -hosts hosts.txt -oA report1
# Nach Ports scannen
~$ das scan -ports all -oA report2
~$ das scan -ports 22,80,443,445 -oA report2
~$ das scan -ports ports.txt -oA report2

Um Nmap gleichzeitig in mehreren Prozessen zu starten, geben Sie den Schalter -parallel an und legen Sie die Anzahl der Arbeiter mit der Option -proc fest (wenn kein Wert angegeben wird, wird standardmäßig die Anzahl der Prozessoren auf dem Rechner verwendet):

root@kitploit:~
~$ das scan -hosts all -oA report -parallel [-proc 4]

Das Ausgabeformat wird mit den Optionen -oX, -oN, -oG und -oA für XML+HTML-Formate, einfaches Textformat, grepable-Format bzw. alle Formate ausgewählt. Wenn das Modul abgeschlossen ist, wird ein Verzeichnis ~/.das/nmap_<DB_NAME> erstellt, das die rohen Nmap-Scan-Berichte enthält.

Sie können den Inhalt der Datenbank auch mit der Option -show überprüfen, bevor Sie die Scans tatsächlich starten:

root@kitploit:~
~$ das scan -hosts all -show

Um einen Bericht unabhängig vom scan-Modul zu erstellen, sollten Sie das report-Modul verwenden. Es sucht nach rohen Nmap-Scan-Berichten im Verzeichnis ~/.das/nmap_<DB_NAME> und verarbeitet und führt sie basierend auf der Option -hosts oder -ports zusammen:

root@kitploit:~
# Ausgaben nach Hosts zusammenführen
~$ das report -hosts all -oA report1
~$ das report -hosts 192.168.1.0/24,10.10.13.37 -oA report1
~$ das report -hosts hosts.txt -oA report1
# Ausgaben nach Ports zusammenführen
~$ das report -ports all -oA report2
~$ das report -ports 22,80,443,445 -oA report2
~$ das report -ports ports.txt -oA report2

📑 Hinweis: Beachten Sie, dass das report-Modul bei der Verarbeitung der Optionen -hosts oder -ports nicht in der Datenbank sucht, sondern direkt nach rohen Nmap-Berichten im Verzeichnis ~/.das/nmap_<DB_NAME> sucht; das bedeutet, dass der Argumentwert -hosts 127.0.0.1 nur dann erfolgreich aufgelöst wird, wenn die Dateien ~/.das/nmap_<DB_NAME>/127-0-0-1.* existieren, und der Argumentwert -ports 80 nur dann erfolgreich aufgelöst wird, wenn die Dateien ~/.das/nmap_<DB_NAME>/port80.* existieren.

example-4.png

  1. Als Ergebnis haben wir jetzt einen einzigen Bericht in allen bekannten Nmap-Formaten (einfacher Text, grepable, XML) sowie einen hübschen HTML-Bericht.

example-5.png