v-byte-cpu/sx🖖 Rápido, moderno, scanner de rede fácil de usar
sx é um scanner de rede de linha de comando projetado para seguir a filosofia UNIX.
O objetivo deste projeto é criar o scanner de rede mais rápido com código limpo e simples.
A maneira mais simples é baixar dos GitHub Releases e colocar o arquivo executável no seu PATH.
Requisitos:
No macOS, instale as Ferramentas de Linha de Comando do Xcode primeiro para que o CGO possa vincular-se à libpcap do sistema:
xcode-select --install
Na raiz da árvore de código-fonte, execute:
go build
Aqui estão alguns exemplos rápidos mostrando como você pode escanear redes com sx.
Escaneie sua rede local e exiba o endereço IP, endereço MAC e o fabricante do hardware associado dos dispositivos conectados:
sx arp 192.168.0.1/24
exemplo de saída:
192.168.0.1 b0:be:76:40:05:8d TP-LINK TECHNOLOGIES CO.,LTD.
192.168.0.111 80:c5:f2:0b:02:e3 AzureWave Technology Inc.
192.168.0.171 88:53:95:2d:3c:af Apple, Inc.
com saída JSON:
sx arp --json 192.168.0.1/24
exemplo de saída:
{"ip":"192.168.0.1","mac":"b0:be:76:40:05:8d","vendor":"TP-LINK TECHNOLOGIES CO.,LTD."}
{"ip":"192.168.0.111","mac":"80:c5:f2:0b:02:e3","vendor":"AzureWave Technology Inc."}
{"ip":"192.168.0.171","mac":"88:53:95:2d:3c:af","vendor":"Apple, Inc."}
aguarde 5 segundos antes de sair para receber pacotes de resposta atrasados, por padrão o sx aguarda 300 milissegundos:
sx arp --exit-delay 5s 192.168.0.1/24
Modo de varredura contínua que reescaneia a rede a cada 10 segundos:
sx arp 192.168.0.1/24 --live 10s
Ao contrário do nmap e de outros scanners que implicitamente realizam requisições ARP para resolver endereços IP em endereços MAC antes da varredura real, o sx utiliza explicitamente o conceito de cache ARP. O arquivo de cache ARP é um arquivo de texto simples contendo uma string JSON em cada linha (arquivo JSONL), que possui os mesmos campos JSON da saída JSON da varredura ARP descrita acima. As varreduras de protocolos de nível superior, como TCP e UDP, leem o arquivo de cache ARP da entrada padrão (stdin) e então iniciam a varredura real.
Isso não apenas simplifica o design do programa, mas também acelera o processo de varredura, já que não é necessário realizar uma varredura ARP toda vez.
Vamos supor que o cache ARP real esteja no arquivo arp.cache. Podemos criá-lo manualmente ou usar a varredura ARP como mostrado abaixo:
sx arp 192.168.0.1/24 --json | tee arp.cache
Assim que tivermos o arquivo de cache ARP, podemos executar varreduras de protocolos de nível superior, como a varredura TCP SYN:
cat arp.cache | sx tcp -p 1-65535 192.168.0.171
exemplo de saída:
192.168.0.171 22
192.168.0.171 443
Neste caso, descobrimos que as portas 22 e 443 estão abertas.
Se você vir send: No buffer space available durante varreduras grandes, isso geralmente significa que o emissor está ultrapassando os buffers do kernel/socket bruto. A primeira correção é adicionar --rate e reduzir a rajada de envio, por exemplo -r 100000/s ou menos, se necessário. Em alguns sistemas, ajustar os limites de buffer/socket do SO também pode ajudar, mas a limitação de taxa é a correção principal.
varredura com saída JSON:
cat arp.cache | sx tcp --json -p 1-65535 192.168.0.171
exemplo de saída:
{"scan":"tcpsyn","ip":"192.168.0.171","port":22}
{"scan":"tcpsyn","ip":"192.168.0.171","port":443}
escaneie múltiplas faixas de portas:
cat arp.cache | sx tcp -p 1-23,25-443 192.168.0.171
ou portas individuais:
cat arp.cache | sx tcp -p 22,443 192.168.0.171
ou use a opção --ports-file para especificar um arquivo com portas ou faixas de portas para escanear, uma por linha.
escaneie pares ip/porta de um arquivo com saída JSON:
cat arp.cache | sx tcp --json -f ip_ports_file.jsonl
Cada linha do arquivo de entrada é uma string JSON, que deve conter os campos ip e port.
arquivo de entrada de exemplo:
{"ip":"10.0.1.1","port":1080}
{"ip":"10.0.2.2","port":1081}
É possível especificar o arquivo de cache ARP usando as opções -a ou --arp-cache:
sx tcp -a arp.cache -p 22,443 192.168.0.171
ou redirecionamento de stdin:
sx tcp -p 22,443 192.168.0.171 < arp.cache
Você também pode usar o subcomando tcp syn em vez de tcp:
cat arp.cache | sx tcp syn -p 22 192.168.0.171
O subcomando tcp é apenas uma abreviação para o subcomando tcp syn, a menos que a opção --flags seja passada, veja abaixo.
O sx suporta varredura com interfaces de rede virtuais (wireguard, openvpn, etc.) e neste caso não é necessário usar o cache arp, pois essas interfaces exigem pacotes IP brutos em vez de quadros Ethernet como entrada. Por exemplo, escaneando um endereço IP em uma rede vpn:
sx tcp 10.1.27.1 -p 80 --json
A maioria dos scanners de rede tenta interpretar os resultados da varredura. Por exemplo, eles dizem "esta porta está fechada" em vez de "recebi um RST". Às vezes eles estão certos. Às vezes não. É mais fácil para iniciantes, mas quando você sabe o que está fazendo, você continua tentando deduzir o que realmente aconteceu a partir da interpretação do programa, especialmente para técnicas de varredura mais avançadas.
O sx tenta superar esses problemas. Ele retorna informações sobre todos os pacotes de resposta para varreduras TCP FIN, NULL, Xmas e TCP personalizadas. A informação contém endereço IP, porta TCP e todas as flags TCP definidas no pacote de resposta.
A varredura TCP FIN e suas outras variações (NULL e Xmas) exploram a RFC793 Seção 3.9:
SEGMENT ARRIVES
If the state is CLOSED (i.e., TCB does not exist) then
all data in the incoming segment is discarded. An incoming segment containing a RST is discarded. An incoming segment not containing a RST causes a RST to be sent in response. The acknowledgment and sequence field values are selected to make the reset sequence acceptable to the TCP that sent the offending segment.
portanto, uma porta fechada deve retornar um pacote com a flag RST.
Esta seção também afirma que:
If the state is LISTEN then
...
Any other control or text-bearing segment (not containing SYN) must have an ACK and thus would be discarded by the ACK processing. An incoming RST segment could not be valid, since it could not have been sent in response to anything sent by this incarnation of the connection. So you are unlikely to get here, but if you do, drop the segment, and return.
a frase principal aqui: drop the segment, e retorne. Então, uma porta aberta na maioria dos sistemas operacionais descartará o pacote TCP contendo quaisquer flags exceto SYN, ACK e RST.
Vamos escanear alguma porta fechada com varredura TCP FIN:
cat arp.cache | sx tcp fin --json -p 23 192.168.0.171
exemplo de saída:
{"scan":"tcpfin","ip":"192.168.0.171","port":23,"flags":"ar"}
O campo flags contém todas as flags TCP no pacote de resposta, onde cada letra representa uma das flags TCP:
s - flag SYNa - flag ACKf - flag FINr - flag RSTp - flag PSHu - flag URGe - flag ECEc - flag CWRn - flag NSNeste caso, descobrimos que a porta 23 enviou pacote de resposta com as flags ACK e RST definidas (resposta típica para uma porta fechada de acordo com o rfc793).
Se escanearmos uma porta aberta, não obtemos resposta (a menos que o firewall esteja falsificando as respostas).
Outros tipos de varreduras TCP podem ser realizados por analogia.
Varredura TCP NULL:
cat arp.cache | sx tcp null --json -p 23 192.168.0.171
Varredura TCP Xmas:
cat arp.cache | sx tcp xmas --json -p 23 192.168.0.171
É possível enviar pacotes TCP com flags TCP personalizadas usando a opção --flags.
Vamos enviar um pacote TCP com as flags SYN, FIN e ACK definidas para identificar o sistema operacional remoto:
cat arp.cache | sx tcp --flags syn,fin,ack --json -p 23 192.168.0.171
Windows e MacOS não responderão a este pacote, mas o Linux enviará um pacote de resposta com a flag RST.
Argumentos possíveis para a opção --flags:
syn - flag SYNack - flag ACKfin - flag FINrst - flag RSTpsh - flag PSHurg - flag URGece - flag ECEcwr - flag CWRns - flag NSO sx pode ajudar a investigar portas UDP abertas. A varredura UDP explora a RFC1122 Seção 4.1.3.1:
If a datagram arrives addressed to a UDP port for which there is no pending LISTEN call, UDP SHOULD send an ICMP Port Unreachable message.
Similar às varreduras TCP, o sx retorna informações sobre todos os pacotes ICMP de resposta para a varredura UDP. A informação contém endereço IP, tipo e código do pacote ICMP definidos no pacote de resposta.
Por exemplo, para detectar servidor DNS no host, execute:
cat arp.cache | sx udp --json -p 53 192.168.0.171
exemplo de saída:
{"scan":"udp","ip":"192.168.0.171","icmp":{"type":3,"code":3}}
Neste caso, descobrimos que o host enviou um pacote de resposta ICMP com tipo Destination Unreachable e código Port Unreachable (resposta típica para uma porta fechada de acordo com o rfc1122).
Firewalls normalmente definem um código ICMP diferente de Port Unreachable e, portanto, podem ser facilmente detectados.
Às vezes, você precisa limitar a velocidade com que os pacotes gerados são enviados. Isso pode ser feito com a opção --rate.
Por exemplo, para limitar a velocidade a 1 pacote a cada 5 segundos:
cat arp.cache | sx tcp --rate 1/5s --json -p 22,80,443 192.168.0.171
Às vezes, você precisa excluir alguns endereços IP e sub-redes da varredura. Isso pode ser feito com a opção --exclude. Ela especifica um arquivo com IPs ou sub-redes em notação CIDR para excluir, um por linha.
Por exemplo, para excluir endereços RFC 1918, crie um arquivo ips.txt com o seguinte conteúdo:
10.0.0.0/8
172.16.0.0/16
192.168.0.0/16
Você também pode inserir comentários e linhas em branco:
# exclude RFC 1918 addresses
10.0.0.0/8 # comment 1
172.16.0.0/12 # comment 2
192.168.0.0/16 # comment 3
0.0.0.0/8 # used in initialization procedures (RFC 6890)
# exclude RFC 5735 addresses
127.0.0.0/8 # loopback address
192.0.0.0/24 # reserved block for IETF protocol assignments
224.0.0.0/4 # allocated for use in IPv4 multicast address assignments
240.0.0.0/4 # reserved for future use
# exclude Amazon network
3.0.0.0/8
# ip addresses are valid as well
1.1.1.1
e execute uma varredura com a opção --exclude ips.txt.
Como exemplo de composição de varredura, você pode combinar varreduras ARP e TCP SYN para criar um scanner de porta TCP contínuo que escaneie periodicamente toda a rede LAN.
Inicie a varredura ARP contínua e salve os resultados no arquivo arp.cache:
sx arp 192.168.0.1/24 --live 10s --json | tee arp.cache
Em outro terminal, inicie a varredura TCP SYN:
while true; do sx tcp -p 1-65535 -a arp.cache -f arp.cache; sleep 30; done
O sx pode detectar proxies SOCKS5 ativos. Para escanear, você deve especificar uma faixa de IP ou um arquivo JSONL com pares ip/porta.
Por exemplo, uma varredura de faixa de IP:
sx socks -p 1080 10.0.0.1/16
escaneie pares ip/porta de um arquivo com saída JSON:
sx socks --json -f ip_ports_file.jsonl
Cada linha do arquivo de entrada é uma string JSON, que deve conter os campos ip e port.
arquivo de entrada de exemplo:
{"ip":"10.0.1.1","port":1080}
{"ip":"10.0.2.2","port":1081}
Você também pode especificar uma faixa de portas para escanear:
sx socks -p 1080-4567 -f ips_file.jsonl
Neste caso, apenas endereços IP serão retirados do arquivo e o campo port não é mais necessário.
sx help
Contribuições, issues e solicitações de funcionalidades são bem-vindas.
Logotipo desenhado por mikhailtsoy.com
Este projeto é licenciado sob a Licença MIT. Veja o arquivo LICENSE para o texto completo da licença.