Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/snovvcrash/divideandscan
Scanners de VulnerabilidadesMapeamento de RedeEscaneamento de PortasScripting e AutomaçãoTestes de Penetração
GitHubsnovvcrash/divideandscan

DivideAndScan

Divida os resultados completos da varredura de portas e use-os para execuções direcionadas do Nmap.

Ver Repositório
3334941há 2 anosRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

DivideAndScan

Divida Et Impera E Escaneie (e também mescle os resultados da varredura)

version python codacy pypi docker

Projetos em Destaque

NixOSNixOSoffsec.tools
NixOSoffsec.tools

DivideAndScan é usado para automatizar eficientemente a rotina de varredura de portas, dividindo-a em 3 fases:

  1. Descobrir portas abertas para um conjunto de alvos.
  2. Executar Nmap individualmente para cada alvo com captura de versão e ações NSE.
  3. Mesclar os resultados em um único relatório Nmap (diferentes formatos disponíveis).

Para a 1ª fase, pretende-se usar um scanner de portas rápido*, cuja saída é analisada e armazenada em um único arquivo de banco de dados (TinyDB). Em seguida, durante a 2ª fase, varreduras Nmap individuais são lançadas para cada alvo com seu conjunto de portas abertas (o multiprocessamento é suportado) de acordo com os dados do banco de dados. Finalmente, na 3ª fase, as saídas Nmap separadas são mescladas em um único relatório em diferentes formatos (XML / HTML / texto simples / grepable) com nMap_Merger. A parte de visualização é fornecida pelo DrawNmap.

Casos de uso potenciais:

  • Testes de penetração / red teaming com um grande escopo para enumerar.
  • Wargames de cibersegurança / laboratórios de treino CTF.
  • Exame de certificação OSCP.

* Scanners de porta disponíveis:

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

AVISO. Todas as informações contidas neste repositório são fornecidas apenas para fins educacionais e de pesquisa. O autor não é responsável por qualquer uso ilegal desta ferramenta.

Como Funciona

how-it-works.png

Como Instalar

Pré-requisitos

Para dividir e escanear com sucesso, precisamos de algumas boas ferramentas de varredura de portas (nos exemplos abaixo, os lançamentos do GitHub são obtidos via eget).

📑 Nota: se você não quiser lidar com dependências no seu sistema operacional host, vá para a parte do Docker.

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

Instalação

DivideAndScan está disponível no PyPI como divideandscan, embora eu recomende instalá-lo a partir do GitHub com pipx para ter sempre a versão mais recente:

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

Há também um lançamento empacotado com shiv (embora com tamanho de arquivo grande):

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

Para fins de depuração, você pode configurar um ambiente de desenvolvimento com poetry:

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

📑 Nota: DivideAndScan usa sudo para executar todos os scanners de porta, então solicitará a senha quando os comandos de varredura forem invocados.

Usando a partir do Docker

dockeri.co

Você pode executar DivideAndScan em um contêiner Docker da seguinte forma:

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

Como a ferramenta requer alguns dados de entrada e produz alguns dados de saída, você deve especificar seu diretório de trabalho atual como ponto de montagem em /app dentro do contêiner. Além disso, publicar a porta 8050 no host permite acessar o aplicativo Dash usado para visualização de relatórios Nmap.

Você pode querer definir um alias para tornar o comando base mais curto:

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

Como Usar

how-to-use.png

1. Preenchendo o BD

Forneça ao módulo add um comando para um scanner de portas rápido descobrir portas abertas em um intervalo desejado.

⚠️ Aviso: por favor, certifique-se de que entende o que está fazendo, porque quase todas as ferramentas de varredura de portas podem danificar o sistema que está sendo testado se usadas de forma inadequada.

root@kitploit:~
# Nmap, a flag -v é sempre necessária para análise correta!
~$ 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'

Quando o módulo inicia seu trabalho, um diretório ~/.das/db é criado onde o arquivo do banco de dados e os resultados brutos da varredura serão colocados quando a rotina do módulo terminar.

2. Varredura Direcionada

Inicie varreduras Nmap direcionadas com o módulo scan. Você pode ajustar a superfície de varredura com a opção -hosts ou -ports:

root@kitploit:~
# Escanear por hosts
~$ 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
# Escanear por portas
~$ das scan -ports all -oA report2
~$ das scan -ports 22,80,443,445 -oA report2
~$ das scan -ports ports.txt -oA report2

Para iniciar o Nmap simultaneamente em múltiplos processos, especifique a opção -parallel e defina o número de workers com a opção -proc (se nenhum valor for fornecido, o padrão será o número de processadores da máquina):

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

O formato de saída é selecionado com as opções -oX, -oN, -oG e -oA para formatos XML+HTML, texto simples, grepable e todos os formatos, respectivamente. Quando o módulo termina seu trabalho, um diretório ~/.das/nmap_<NOME_DB> é criado contendo os relatórios brutos de varredura Nmap.

Além disso, você pode inspecionar o conteúdo do banco de dados com a opção -show antes de realmente iniciar as varreduras:

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

3 (Opcional). Mesclando os Relatórios

Para gerar um relatório independentemente do módulo scan, você deve usar o módulo report. Ele pesquisará relatórios brutos de varredura Nmap no diretório ~/.das/nmap_<NOME_DB> e os processará e mesclará com base na opção -hosts ou -ports:

root@kitploit:~
# Mesclar saídas por hosts
~$ 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
# Mesclar saídas por portas
~$ das report -ports all -oA report2
~$ das report -ports 22,80,443,445 -oA report2
~$ das report -ports ports.txt -oA report2

📑 Nota: lembre-se de que o módulo report não pesquisa no BD ao processar as opções -hosts ou -ports, mas procura relatórios brutos Nmap diretamente no diretório ~/.das/nmap_<NOME_DB>; isso significa que o valor do argumento -hosts 127.0.0.1 será resolvido com sucesso apenas se os arquivos ~/.das/nmap_<NOME_DB>/127-0-0-1.* existirem, e o valor do argumento -ports 80 será resolvido com sucesso apenas se os arquivos ~/.das/nmap_<NOME_DB>/port80.* existirem.

🔥 Exemplo 🔥

Vamos enumerar portas abertas para todas as máquinas ativas no Hack The Box.

  1. Adicione mapeamentos "host ⇄ portas abertas" ao banco de dados com Masscan. Para fins de demonstração, excluirei o intervalo de portas dinâmicas para evitar coisas desnecessárias usando -p1-49151. Na segunda captura de tela, estou revisando os resultados da varredura por hosts e por portas:
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. Lance processos Nmap para cada alvo para enumerar apenas as portas que nos interessam (as portas abertas). Na segunda captura de tela, estou fazendo o mesmo, mas iniciando processos Nmap simultaneamente:
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

example-4.png

  1. Como resultado, agora temos um único relatório em todos os formatos familiares do Nmap (texto simples, grepable, XML), bem como um relatório HTML bonito.

example-5.png

Traga Seu Próprio Scanner!

Você pode emparelhar seu scanner de portas favorito com DivideAndScan implementando um único método parse para sua saída em das/parsers/DUMMY_SCANNER.py (veja exemplo para masscan):

root@kitploit:~
from das.parsers import IAddPortscanOutput


class AddPortscanOutput(IAddPortscanOutput):
    """Classe filha para processar a saída do DUMMY_SCANNER."""

    def parse(self):
        """
        Analisador de saída bruta do DUMMY_SCANNER.

        :return: um par de valores (nome do arquivo de saída bruta do portscan, número de hosts adicionados ao BD)
        :rtype: tuple
        """
        hosts = set()
        for line in self.portscan_raw:
            # Implementação do analisador DUMMY_SCANNER
            pass

        return (self.portscan_out, len(hosts))

Ajuda

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}  |
 -----------------------------------------------------------------------------------------------

argumentos posicionais:
  {db,add,scan,dns,report,parse,draw,tree,help}
    db                  utilitários para manipulações manuais do BD
    add                 executar uma varredura completa de portas e adicionar a saída ao BD
    scan                executar varreduras Nmap direcionadas contra hosts e portas do BD
    dns                 mapear nomes de domínio de um arquivo de entrada para endereços IP correspondentes do BD
    report              mesclar saídas Nmap separadas em um único relatório (https://github.com/CBHue/nMap_Merger)
    parse               analisar relatórios Nmap XML brutos por nomes de serviço e imprimir entradas no formato {serviço}://{host}:{porta}
    draw                visualizar relatórios Nmap XML (https://github.com/jor6PS/DrawNmap)
    tree                mostrar o conteúdo do diretório ~/.das/ usando tree
    help                mostrar o diálogo --help embutido de um scanner de portas selecionado

opções:
  -h, --help            mostrar esta mensagem de ajuda e sair
  -db DB                nome do BD para trabalhar

Psst, ei amigo... Quer fazer um p0r7 5c4nn1n6 organizado?

ToDo

  • Adicionar parser para projectdiscovery/naabu
  • Adicionar parser para elddy/NimScan
  • Adicionar parser para sx
  • Adicionar parser para ZMap
  • Armazenar nomes de host (se houver) ao lado de seus valores IP
  • Adicionar opção fuff para automatizar fuzzing de diretórios web (adicionado módulo parse)
Baixar ferramenta