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/flags-alt/abyss-c2
Frameworks de Testes de PenetraçãoReconhecimentoScanners de VulnerabilidadesFrameworks de ExploraçãoSegurança IoTMecanismos de PersistênciaMovimento LateralPós-ExploraçãoComando e ControleAprendizado e Educação
GitHubflags-alt/abyss-c2
216há 3 mesesAinda não revisado

abyss-c2

Framework C2 full-stack para exploração de IoT (CVE-2020-25078) com painel web em tempo real, aquisição de alvos de múltiplas fontes, varredura de vulnerabilidades, pós-exploração, persistência, movimentação lateral e orquestração de botnet.

Ver Repositório

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

ABYSS C2 — Estrutura de Exploração de DVR HiSilicon

⚠️ APENAS PARA FINS EDUCACIONAIS / DE DEMONSTRAÇÃO

Este software é fornecido exclusivamente para fins educacionais e de pesquisa de segurança autorizada. Ele foi projetado para demonstrar vulnerabilidades comuns de IoT e técnicas de pós-exploração em um ambiente controlado e autorizado.

Você NÃO DEVE usar este software em:

  • Qualquer sistema ou dispositivo que você não possua
  • Qualquer sistema ou dispositivo para o qual você não tenha autorização explícita por escrito para testar
  • Qualquer infraestrutura de produção sem aprovação prévia

O criador NÃO assume nenhuma responsabilidade ou obrigação por qualquer uso indevido, dano ou atividade ilegal conduzida com este software. Ao usar este software, você reconhece que é o único responsável por garantir a conformidade com todas as leis e regulamentos aplicáveis em sua jurisdição. O acesso não autorizado a sistemas de computador é ilegal sob leis como o Computer Fraud and Abuse Act (CFAA) e estatutos similares em todo o mundo.

Este projeto existe para demonstrar:

  • Como o CVE-2020-25078 (divulgação de informações do DVR HiSilicon) funciona
  • Fraquezas de segurança de dispositivos IoT e por que as atualizações de firmware são importantes
  • Técnicas de pós-exploração para que os defensores entendam as TTPs dos atacantes
  • A importância da segmentação de rede e higiene de credenciais

Se você não possui, não mexa.


Visão Geral

ABYSS C2 é uma estrutura de Comando & Controle full-stack construída em Python/Flask com um painel web em tempo real com tema escuro. Ela demonstra toda a cadeia de ataque contra dispositivos IoT (especificamente DVRs e câmeras IP baseadas em HiSilicon afetadas pelo CVE-2020-25078) — desde reconhecimento e aquisição de alvos até exploração, pós-exploração, persistência, movimento lateral e exfiltração de dados.

CVE-2020-25078 é uma vulnerabilidade de travessia de caminho / divulgação de informações em dispositivos DVR/NVR baseados em HiSilicon Hi3516/Hi3518/Hi3519. Atacantes não autenticados podem acessar arquivos de configuração (/mnt/mtd/Config/Account*) contendo credenciais de administrador em texto simples por meio de travessia de diretório no servidor HTTP.

Recursos

  • Painel Web em Tempo Real — UI de página única com tema escuro, atualizações ao vivo via WebSocket, 8 guias operacionais, terminal integrado
  • Aquisição de Alvos — Obter dispositivos vulneráveis via APIs Shodan, FOFA, ZoomEye, além de scraping gratuito (Censys, Onyphe, faceta gratuita do Shodan, InternetDB)
  • Scanner de Vulnerabilidades — Scanner TCP/HTTP multi-thread com suporte a CIDR, fingerprinting de DVR, extração de credenciais
  • Pós-Exploração — Shell telnet interativo, execução em massa de comandos em todos os dispositivos controlados, upload de arquivos
  • Varredura de Vulnerabilidades Web — Detecção de CVEs (Log4Shell, Spring4Shell, Confluence, Ghostcat, Struts2, Jenkins, GitLab, Exchange, F5 BIG-IP, Citrix, MOVEit, Ivanti, vCenter, PHPUnit, GeoServer, Solr, WordPress) e testes de classes de bugs (SQLi, LFI, SSRF, XXE, Injeção de Comandos, ataques JWT, Tomada de Subdomínio, Contrabando HTTP, GraphQL, CORS)
  • Exploração de Rede — SMB/EternalBlue, RDP/BlueKeep, VNC, FTP, SNMP, Redis, MongoDB, Elasticsearch, CouchDB, MySQL/MSSQL/PostgreSQL, Memcached, IPMI, Mirai-IoT
  • Ataques de Credenciais — Força bruta multiprotocolo (Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC), pulverização de credenciais, cofre de credenciais
  • Reconhecimento — Consulta/importação ASN, reconhecimento DNS completo (A/AAAA/MX/NS/TXT/SOA + brute de subdomínios + AXFR), fingerprinting TLS JARM, detecção de WAF, consulta GeoIP, varredura de portas com múltiplos presets
  • Persistência — Injeção de chave pública SSH, backdoors cron, persistência init.d/systemd, implantação automatizada completa
  • Reverse Shells — Gerador de payload (bash, python, perl, php, nc, ruby, node, lua, etc.), ouvinte multisessão com interação
  • Pivoting — Execução de cadeia multi-hop, relay TCP, proxy SOCKS5 através de hosts comprometidos, varredura automática de pivot em redes locais
  • Orquestração de Botnet — Marcação/agrupamento de bots, comandos fan-out, verificações de saúde, implantação de payload
  • Inteligência e Notificações — Notificações via webhook Telegram/Discord, integração AbuseIPDB, captura de screenshot de câmera
  • Agendador — Tarefas recorrentes automatizadas (varreduras, reconhecimento, verificações de saúde)

Arquitetura```

panel/ ├── server.py # Flask + SocketIO C2 web panel (~1200 lines, 50+ API routes) ├── database.py # SQLite ORM — 11 tables (cameras, vulns, creds, shells, DNS, ASN, etc.) ├── scanner.py # Multi-threaded TCP/HTTP vulnerability scanner ├── exploit.py # CVE-2020-25078 exploit — 37 vulnerable paths, 14 credential parsers ├── telnet_client.py # Raw telnet command execution against owned devices ├── brute.py # Multi-threaded brute force engine ├── web_exploit.py # Full website vulnerability scanner (CMS detection, exposed files, SQLi) ├── web_cves.py # CVE scanner — Log4Shell, Spring4Shell, Confluence, Ghostcat, etc. ├── web_bugs.py # Bug class scanner — SQLi, LFI, SSRF, XXE, CmdI, JWT, etc. ├── web_brute.py # Web brute force — forms, WordPress xmlrpc, Basic Auth, cred stuffing ├── network_exploit.py # Network service exploit scanner — SMB, RDP, VNC, databases, etc. ├── cred_spray.py # Multi-service credential spraying ├── recon_asn.py # ASN import, organization search, IP-to-ASN lookup ├── recon_dns.py # DNS recon — all record types, subdomain brute, zone transfer ├── recon_jarm.py # JARM TLS server fingerprinting ├── recon_waf.py # WAF detection and identification ├── recon_geoip.py # GeoIP lookup and bulk IP geolocation ├── portscan.py # TCP port scanner with banner grabbing, SYN option, multiple presets ├── persistence.py # SSH key injection, cron backdoors, full deployment ├── reverse_shell.py # Payload generator + multi-session listener ├── pivot_chain.py # Multi-hop command execution and TCP relay ├── socks_pivot.py # SOCKS5 proxy through compromised hosts ├── botnet.py # Bot grouping, fan-out commands, health checks, payload deployment ├── intel.py # Telegram/Discord webhooks, AbuseIPDB, screenshot capture ├── scheduler.py # APScheduler-based job scheduling ├── proxy_rotation.py # Proxy list rotation for stealth ├── stealth.py # Traffic obfuscation utilities ├── inject_key.py # SSH key injection variants ├── inject_ssh.py # SSH-based injection ├── launch.py # Simple launcher wrapper ├── auto_exploit.py # Automated exploitation routines ├── templates/ │ └── index.html # Dark-themed SPA — 8 tabs, real-time updates, terminal └── requirements.txt # Python dependencies

root@kitploit:~
### Esquema do Banco de Dados

O banco de dados SQLite (`cameras.db`, criado automaticamente na primeira execução) contém 11 tabelas:

| Tabela | Propósito |
|--------|-----------|
| `cameras` | Dispositivos comprometidos — IP, credenciais, modelo, firmware, serial, status |
| `command_log` | Trilha de auditoria completa de cada comando executado e sua saída |
| `scan_results` | Histórico de varredura — quais IPs foram escaneados e se eram vulneráveis |
| `web_vulns` | Vulnerabilidades web descobertas (CVE, gravidade, evidência) |
| `network_vulns` | Vulnerabilidades de serviços de rede descobertas |
| `shells` | Sessões de shell reverso ativas |
| `dns_records` | Resultados de reconhecimento DNS |
| `cred_vault` | Credenciais coletadas organizadas por serviço |
| `asn_targets` | Prefixos ASN e intervalos de IP importados |
| `web_targets` | Alvos web com metadados (status, servidor, CMS, JARM, WAF) |
| `scan_jobs` | Rastreamento de tarefas — tipo de varredura, alvo, duração, contagem de resultados |
| `scan_log` | Registro de atividade em nível de módulo para auditoria |

---

## Instalação

### Pré-requisitos

- Python 3.10 ou mais recente
- pip
- Git (opcional)

### Passo 1 — Clonar ou baixar```bash
git clone https://github.com/YOUR_USERNAME/abyss-c2.git
cd abyss-c2

Passo 2 — Criar ambiente virtual (recomendado)```bash

python -m venv venv

Windows

venv\Scripts\activate

Linux / macOS

source venv/bin/activate

root@kitploit:~
### Passo 3 — Instalar dependências```bash
pip install -r requirements.txt

Passo 4 — (Opcional) Baixar wordlist

Os módulos de força bruta esperam uma wordlist rockyou.txt na raiz do projeto. Devido aos limites de tamanho de arquivo do GitHub (100MB), ela NÃO está incluída neste repositório.```bash

On Kali Linux, rockyou.txt is typically at:

cp /usr/share/wordlists/rockyou.txt.gz . gunzip rockyou.txt.gz

Or download from SecLists:

https://github.com/danielmiessler/SecLists/blob/master/Passwords/Leaked-Databases/rockyou.txt.tar.gz

root@kitploit:~
Se você não precisar de força bruta, os outros módulos funcionam sem uma wordlist.

### Passo 5 — Iniciar```bash
python server.py

Abra http://localhost:5000 no seu navegador.

O banco de dados é criado automaticamente na primeira execução — nenhuma configuração necessária.


Guia de Uso

O Painel

Quando você abre o painel pela primeira vez, verá:

  • Barra de Estatísticas — Contadores ao vivo: Escaneados, Vulneráveis, Comprometidos, Online
  • 8 Abas — Dispositivos, Reconhecimento, CVEs Web, Rede, Persistência, Rev Shells, Botnet, Configurações
  • Terminal Embutido — Shell interativa para qualquer dispositivo selecionado
  • Painel Lateral — Controles de varredura, informações do alvo, comando em massa, conjunto de ferramentas de pivô/carregamento/força bruta

Aba 1 — Dispositivos (Operações Principais)

Este é o seu centro de comando. Aqui você pode:

Buscar alvos de motores de busca:

  • Selecione a fonte: Shodan, FOFA, ZoomEye, ou FREE (raspagem — nenhuma chave de API necessária)
  • Insira a chave de API se usar Shodan/FOFA/ZoomEye
  • Consulta personalizada ou deixe em branco para consultas padrão de DVR/câmera
  • Clique em BUSCAR & ESCANEAR — os alvos são automaticamente escaneados ao chegar

Varredura manual:

  • Insira um intervalo CIDR (ex.: 192.168.1.0/24)
  • Ou um único IP e porta
  • Defina o número de threads (padrão 50)
  • Clique em ESCANEAR

Uma vez que dispositivos são comprometidos (aparecem na tabela):

  • Clique em qualquer linha para selecioná-la — detalhes aparecem no painel lateral
  • O terminal inferior é ativado para aquele dispositivo
  • Use botões de comando rápido (CPU, UNAME, PS, IFCFG, NETSTAT, CREDS, PASSWD, LS)
  • Digite comandos personalizados no terminal e pressione Enter

Operações em massa:

  • Comando em Massa — execute o mesmo comando em TODOS os dispositivos possuídos simultaneamente
  • Varredura de Pivô — use um dispositivo comprometido para escanear sua rede local em busca de mais alvos
  • Carregar Arquivo — carregue um arquivo para o dispositivo remoto via codificação base64
  • Força Bruta — força bruta de credenciais telnet no dispositivo selecionado

Modo de varredura web (alterne com o botão WEB):

  • Insira uma URL ou IP para varredura completa de vulnerabilidades web
  • Detecção de CMS, arquivos de configuração expostos, parâmetros de injeção SQL
  • BUSCAR & ESCANEAR pega alvos web do Shodan free e os escaneia

Aba 2 — Reconhecimento

Seis módulos de reconhecimento:

MóduloO que faz
Consulta ASNImportar todos os prefixos de um ASN, pesquisar organizações, consultar a qual ASN um IP pertence
Recon DNSEnumeração completa de DNS — registros A, AAAA, MX, NS, TXT, SOA, CNAME + força bruta de subdomínios + tentativas de transferência de zona AXFR
Impressão Digital JARMImpressão digital de servidor TLS — identifica a implementação TLS mesmo atrás de balanceadores de carga
Detecção de WAFIdentifica qual WAF (Cloudflare, CloudFront, Imperva, Akamai, etc.) está na frente de um alvo
GeoIPGeolocalização e consulta de ISP para qualquer IP
Varredura de PortasVarredura de portas TCP com 6 predefinições — Web, Top 100, Top 1000, Completa, IoT, Bancos de Dados — com captura de banner

Aba 3 — CVEs Web

Scanner de CVE — Verifica 20+ CVEs conhecidas: Log4Shell (CVE-2021-44228), Spring4Shell (CVE-2022-22965), Confluence (CVE-2022-26134), Ghostcat (CVE-2020-1938), Struts2 (CVE-2017-5638), Jenkins (CVE-2018-1000861), GitLab (CVE-2021-22205), Exchange ProxyShell/ProxyLogon, F5 BIG-IP (CVE-2022-1388), Citrix (CVE-2019-19781), MOVEit (CVE-2023-34362), Ivanti (CVE-2024-21887), vCenter (CVE-2021-21972), PHPUnit (CVE-2017-9841), GeoServer (CVE-2024-36401), Apache Solr (CVE-2019-17558), e vulnerabilidades de plugins WordPress.

Scanner de Classes de Bugs — Testa para: Injeção SQL Cega, Injeção de Comandos, Inclusão de Arquivo Local, Server-Side Request Forgery, XML External Entity, ataques JWT, Subdomain Takeover, Contrabando de Requisição HTTP, introspecção GraphQL, configuração incorreta de CORS.

Força Bruta Web — Quatro modos:

  • Força bruta de formulário (detecta automaticamente formulários de login e parâmetros)
  • Força bruta xmlrpc do WordPress
  • Força bruta de Autenticação Básica HTTP
  • Preenchimento de credenciais (usa credenciais previamente colhidas)

Os resultados aparecem na tabela Vulnerabilidades Descobertas abaixo.

Aba 4 — Rede

Scanner de Exploração de Rede — Verifica serviços de rede comuns por vulnerabilidades conhecidas: SMB (EternalBlue, SMBGhost), RDP (BlueKeep), VNC (bypass de autenticação), FTP (acesso anônimo), SNMP (comunidades padrão), Redis (sem autenticação), MongoDB (sem autenticação), Elasticsearch (sem autenticação), CouchDB (sem autenticação), MySQL/MSSQL/PostgreSQL (credenciais padrão), Memcached (sem autenticação), IPMI (bypass de autenticação), padrões Mirai-IoT.

Spray de Credenciais — Pulveriza credenciais colhidas ou personalizadas em múltiplos serviços: Telnet, SSH, FTP, HTTP Basic, WordPress, SMB, Redis, MySQL, MongoDB, VNC, ou TODOS de uma vez.

Os resultados preenchem a tabela Vulnerabilidades de Rede e o Cofre de Credenciais.

Aba 5 — Persistência

Três ações de implantação para hosts comprometidos:

  • Injeção de Chave SSH — Adiciona sua chave pública a /root/.ssh/authorized_keys (ou múltiplos caminhos)
  • Backdoor Cron — Instala um job cron que chama de volta ao seu servidor C2
  • Implantação Completa — Todas as técnicas combinadas: chave SSH + cron + persistência init.d/systemd

Cadeia de Pivô — Execute comandos através de múltiplos hosts intermediários:``` hop1 → hop2 → hop3 → command

root@kitploit:~
**SOCKS Pivot** — Iniciar um proxy SOCKS5 local que roteia o tráfego através de um dispositivo comprometido, permitindo usar proxychains ou qualquer ferramenta compatível com SOCKS para alcançar a rede interna.

### Aba 6 — Reverse Shells

- **Gerador de Payload** — Selecionar tipo de shell (bash, python, perl, php, nc, ruby, node, lua, etc.), definir LHOST/LPORT, clicar em GERAR — o payload aparece, clicar para copiar
- **Listener** — Iniciar um listener em qualquer porta, gerencia automaticamente múltiplas conexões simultâneas
- **Sessões Ativas** — Clicar em qualquer sessão para interagir, digitar comandos e clicar em ENVIAR
- **Todas as Shells** — Tabela mostra todos os callbacks de reverse shell recebidos, com status

### Aba 7 — Botnet

Para gerenciar grandes grupos de dispositivos comprometidos:

- **Comando Fan-Out** — Executar um comando em todos os bots (opcionalmente filtrado por tag)
- **Health Check** — Pingar todos os bots e reportar status online/offline
- **Tag Bot** — Atribuir tags aos bots para agrupamento (ex.: `br`, `cameras`, `alto-valor`)
- **Deploy Payload** — Enviar um payload para todos os bots em um grupo de tags
- **Resumo do Bot** — Mostra contagem total, contagem online e detalhamento por tag

### Aba 8 — Configurações

- **Telegram/Discord** — Configurar webhooks para notificações de eventos (novo comprometimento, varredura concluída, etc.)
- **AbuseIPDB** — Verificar reputação de IP
- **Screenshot** — Capturar uma screenshot HTTP da interface web de uma câmara
- **Agendador** — Configurar tarefas recorrentes (ex.: health check a cada 3600 segundos)
- **Log de Varredura** — Trilha de auditoria completa de todas as operações dos módulos, filtrável por tipo de módulo

---

## Referência da API

A API REST completa está disponível em `http://localhost:5000/api/`. Endpoints principais:

| Endpoint | Método | Descrição |
|----------|--------|-------------|
| `/api/cameras` | GET | Listar todos os dispositivos comprometidos |
| `/api/cameras/<ip>` | GET | Obter detalhes do dispositivo |
| `/api/stats` | GET | Estatísticas do dashboard |
| `/api/scan/start` | POST | Iniciar scanner (CIDRs, alvos, threads) |
| `/api/scan/stop` | POST | Parar scanner |
| `/api/scan/status` | GET | Estado de execução do scanner + estatísticas |
| `/api/exploit/check` | POST | Verificar IP único para CVE-2020-25078 |
| `/api/fetch_targets` | POST | Obter alvos do Shodan/FOFA/ZoomEye/Gratuito |
| `/api/web_scan` | POST | Varredura completa de vulnerabilidades web |
| `/api/web_cves/scan` | POST | Varredura de CVEs contra alvo |
| `/api/web_bugs/scan` | POST | Varredura de classes de bugs contra alvo |
| `/api/web_brute` | POST | Força bruta web |
| `/api/network/scan` | POST | Varredura de exploração de rede |
| `/api/cred_spray` | POST | Pulverização de credenciais |
| `/api/portscan` | POST | Varredura de portas TCP |
| `/api/recon/asn` | POST | Importação/consulta/pesquisa de ASN |
| `/api/recon/dns` | POST | Recon de DNS |
| `/api/recon/jarm` | POST | Impressão digital JARM |
| `/api/recon/waf` | POST | Deteção de WAF |
| `/api/recon/geoip` | POST | Consulta GeoIP |
| `/api/persistence/deploy` | POST | Implantar persistência (ssh_key/cron/full) |
| `/api/revshell/generate` | POST | Gerar payload de reverse shell |
| `/api/revshell/listen` | POST | Iniciar listener de reverse shell |
| `/api/revshell/stop` | POST | Parar listener |
| `/api/botnet/bots` | GET | Lista de bots + resumo de grupos |
| `/api/botnet/fanout` | POST | Executar comando em todos os bots |
| `/api/botnet/health` | POST | Health check dos bots |
| `/api/botnet/deploy` | POST | Implantar payload em bots |
| `/api/socks/start` | POST | Iniciar proxy SOCKS5 |
| `/api/socks/stop` | POST | Parar proxy SOCKS5 |
| `/api/intel/config` | GET/POST | Obter/definir configuração de notificações |
| `/api/intel/screenshot` | POST | Capturar screenshot de câmara |
| `/api/intel/notify` | POST | Enviar notificação de teste |
| `/api/scheduler/jobs` | GET | Listar tarefas agendadas |
| `/api/scheduler/add` | POST | Adicionar tarefa agendada |
| `/api/scheduler/remove` | POST | Remover tarefa agendada |
| `/api/credentials` | GET | Cofre de credenciais |
| `/api/web_vulns` | GET | Lista de vulnerabilidades web |
| `/api/network_vulns` | GET | Lista de vulnerabilidades de rede |
| `/api/shells` | GET | Todas as sessões de reverse shell |
| `/api/scan_log` | GET | Log de auditoria com filtros de módulo/alvo |
| `/api/scan_jobs` | GET | Histórico de trabalhos de varredura |

Eventos WebSocket (SocketIO):
- `scanner_event` — Progresso da varredura em tempo real (vivo, vulnerável, possuído, status)
- `stats_update` — Alteração nas estatísticas do dashboard
- `cameras_list` — Atualização da tabela de câmaras
- `new_camera` — Novo dispositivo comprometido
- `command_result` — Saída de comando Telnet
- `mass_result` / `mass_result_item` — Resultados de comando em massa
- `brute_event` — Progresso da força bruta
- `web_cve_event` / `web_cves_done` — Progresso da varredura de CVEs
- `web_bug_event` / `web_bugs_done` — Progresso da varredura de bugs
- `network_event` / `network_done` — Progresso da varredura de rede
- `spray_event` / `spray_done` — Progresso da pulverização de credenciais
- `portscan_event` / `portscan_done` — Progresso da varredura de portas
- `persistence_result` — Resultado da implantação de persistência
- `revshell_event` — Dados/conexões de reverse shell
- `botnet_event` / `botnet_fanout_done` — Operações de botnet

---

## Detalhes Técnicos

### Cadeia de Exploração CVE-2020-25078

1. **Verificação de atividade** — Conexão TCP à porta 80
2. **Impressão digital HTTP** — Verificar resposta por 15 assinaturas conhecidas de DVR (`AppName="Hipcam"`, `hi3516`, `WEB SERVICE`, etc.)
3. **Path traversal** — Tentar 37 caminhos vulneráveis conhecidos (`/../../../../../../../../../mnt/mtd/Config/Account1`, etc.)
4. **Extração de credenciais** — Analisar resposta com 14 padrões de regex abrangendo formatos INI, XML, JSON, URL-encoded, binário, base64, delimitado por dois-pontos e específicos de DVR
5. **Filtragem de lixo** — Remoção agressiva de falsos positivos (tags HTML, headers HTTP, palavras comuns)
6. **Fallback padrão** — Se o dispositivo é vulnerável mas não foram extraídas credenciais, tentar 22 pares de credenciais padrão conhecidos

### Arquitetura do Scanner

- Pool de threads com número configurável de workers (padrão 50)
- Distribuição de alvos baseada em fila
- Emissão de eventos SocketIO em tempo real para a UI
- Estatísticas thread-safe com mutex locks
- Expansão de faixas CIDR com exclusão de rede/broadcast
- Varredura multi-porta (80, 8080, 443, 8443, 554, 8000, 81, 88, 8888, 37777)

---

## Aviso Legal

**ESTE SOFTWARE É FORNECIDO APENAS PARA FINS EDUCACIONAIS E DE DEMONSTRAÇÃO.**

Este projeto destina-se a ser usado exclusivamente em testes de segurança autorizados, ambientes educacionais ou em sistemas que você possui. As técnicas aqui demonstradas são bem conhecidas na indústria de cibersegurança e estão documentadas para ajudar defensores a entender metodologias de ataque.

**Ao usar este software, você concorda que:**

1. Só o utilizará em sistemas que você possui ou para os quais tem autorização escrita explícita para testar
2. É responsável pela conformidade com todas as leis locais, estaduais, nacionais e internacionais aplicáveis
3. O(s) criador(es) e colaborador(es) deste projeto **não assumem absolutamente nenhuma responsabilidade** por qualquer:
   - Uso não autorizado ou ilegal deste software
   - Dano causado pelo uso ou uso indevido deste software
   - Consequências legais resultantes do uso deste software
4. Este software não oferece garantia de qualquer tipo, expressa ou implícita

**Se você não tem certeza se seu caso de uso é legal ou autorizado, NÃO use este software.**

A existência deste projeto não constitui incentivo a se envolver em atividades ilegais. Ele existe porque entender as técnicas ofensivas é essencial para construir defesas eficazes.

---

## Licença

Este projeto é fornecido como está para fins educacionais. Sem garantia. Sem responsabilidade. Use por sua própria conta e risco.

---

*Lembre-se: a pesquisa em segurança existe para tornar os sistemas mais seguros, não para quebrá-los. Use este conhecimento para defender, não para atacar.*
Baixar ferramenta