v-byte-cpu/sx🖖 Scanner réseau rapide, moderne et facile à utiliser.
sx est le scanner réseau en ligne de commande conçu pour suivre la philosophie UNIX.
L'objectif de ce projet est de créer le scanner réseau le plus rapide avec un code propre et simple.
Le moyen le plus simple est de télécharger depuis GitHub Releases et de placer le fichier exécutable dans votre PATH.
Prérequis :
Sur macOS, installez d'abord les Xcode Command Line Tools pour que CGO puisse lier la libpcap système :
xcode-select --install
Depuis la racine de l'arborescence des sources, exécutez :
go build
Voici quelques exemples rapides montrant comment scanner des réseaux avec sx.
Scannez votre réseau local et affichez l'adresse IP, l'adresse MAC et le fabricant matériel associé des périphériques connectés :
sx arp 192.168.0.1/24
exemple de sortie :
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.
avec sortie JSON :
sx arp --json 192.168.0.1/24
exemple de sortie :
{"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."}
attendez 5 secondes avant de quitter pour recevoir les paquets de réponse retardés, par défaut sx attend 300 millisecondes :
sx arp --exit-delay 5s 192.168.0.1/24
Mode de scan en direct qui rescanner le réseau toutes les 10 secondes :
sx arp 192.168.0.1/24 --live 10s
Contrairement à nmap et autres scanners qui effectuent implicitement des requêtes ARP pour résoudre les adresses IP en adresses MAC avant le scan réel, sx utilise explicitement le concept de cache ARP. Un fichier de cache ARP est un fichier texte simple contenant une chaîne JSON par ligne (fichier JSONL), qui a les mêmes champs JSON que la sortie JSON du scan ARP décrite ci-dessus. Les scans de protocoles de plus haut niveau comme TCP et UDP lisent le fichier de cache ARP depuis l'entrée standard, puis démarrent le scan réel.
Cela simplifie non seulement la conception du programme, mais accélère également le processus de scan, car il n'est pas nécessaire d'effectuer un scan ARP à chaque fois.
Supposons que le cache ARP réel se trouve dans le fichier arp.cache. Nous pouvons le créer manuellement ou utiliser le scan ARP comme montré ci-dessous :
sx arp 192.168.0.1/24 --json | tee arp.cache
Une fois que nous avons le fichier de cache ARP, nous pouvons lancer des scans de protocoles de plus haut niveau comme le scan TCP SYN :
cat arp.cache | sx tcp -p 1-65535 192.168.0.171
exemple de sortie :
192.168.0.171 22
192.168.0.171 443
Dans ce cas, nous découvrons que les ports 22 et 443 sont ouverts.
Si vous voyez send: No buffer space available lors de scans volumineux, cela signifie généralement que l'expéditeur dépasse les tampons du noyau/des sockets raw. La première correction consiste à ajouter --rate et à réduire la rafale d'envoi, par exemple -r 100000/s ou moins si nécessaire. Sur certains systèmes, ajuster les limites des sockets/tampons du système d'exploitation peut également aider, mais la limitation de débit est la correction principale.
scan avec sortie JSON :
cat arp.cache | sx tcp --json -p 1-65535 192.168.0.171
exemple de sortie :
{"scan":"tcpsyn","ip":"192.168.0.171","port":22}
{"scan":"tcpsyn","ip":"192.168.0.171","port":443}
scan de plusieurs plages de ports :
cat arp.cache | sx tcp -p 1-23,25-443 192.168.0.171
ou ports individuels :
cat arp.cache | sx tcp -p 22,443 192.168.0.171
ou utilisez l'option --ports-file pour spécifier un fichier avec des ports ou plages de ports à scanner, un par ligne.
scan de paires ip/port depuis un fichier avec sortie JSON :
cat arp.cache | sx tcp --json -f ip_ports_file.jsonl
Chaque ligne du fichier d'entrée est une chaîne JSON, qui doit contenir les champs ip et port.
exemple de fichier d'entrée :
{"ip":"10.0.1.1","port":1080}
{"ip":"10.0.2.2","port":1081}
Il est possible de spécifier le fichier de cache ARP à l'aide des options -a ou --arp-cache :
sx tcp -a arp.cache -p 22,443 192.168.0.171
ou redirection stdin :
sx tcp -p 22,443 192.168.0.171 < arp.cache
Vous pouvez également utiliser la sous-commande tcp syn au lieu de tcp :
cat arp.cache | sx tcp syn -p 22 192.168.0.171
tcp est simplement un raccourci pour la sous-commande tcp syn sauf si l'option --flags est passée, voir ci-dessous.
sx prend en charge le scan avec des interfaces réseau virtuelles (wireguard, openvpn, etc.) et dans ce cas, il n'est pas nécessaire d'utiliser le cache ARP, car ces interfaces nécessitent des paquets IP bruts plutôt que des trames Ethernet en entrée. Par exemple, scanner une adresse IP sur un réseau VPN :
sx tcp 10.1.27.1 -p 80 --json
La plupart des scanners réseau essaient d'interpréter les résultats du scan. Par exemple, ils disent "ce port est fermé" au lieu de "j'ai reçu un RST". Parfois ils ont raison. Parfois non. C'est plus facile pour les débutants, mais quand vous savez ce que vous faites, vous essayez de déduire ce qui s'est réellement passé à partir de l'interprétation du programme, surtout pour des techniques de scan plus avancées.
sx essaie de surmonter ces problèmes. Il retourne des informations sur tous les paquets de réponse pour les scans TCP FIN, NULL, Xmas et TCP personnalisés. Les informations contiennent l'adresse IP, le port TCP et tous les flags TCP définis dans le paquet de réponse.
Le scan TCP FIN et ses autres variantes (NULL et Xmas) exploitent la RFC793 Section 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.
donc un port fermé devrait retourner un paquet avec le flag RST.
Cette section indique également :
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.
la phrase principale ici : drop the segment, and return. Donc un port ouvert sur la plupart des systèmes d'exploitation abandonnera le paquet TCP contenant n'importe quel flag sauf SYN, ACK et RST.
Scannons un port fermé avec le scan TCP FIN :
cat arp.cache | sx tcp fin --json -p 23 192.168.0.171
exemple de sortie :
{"scan":"tcpfin","ip":"192.168.0.171","port":23,"flags":"ar"}
Le champ flags contient tous les flags TCP dans le paquet de réponse, où chaque lettre représente l'un des flags TCP :
s - flag SYNa - flag ACKf - flag FINr - flag RSTp - flag PSHu - flag URGe - flag ECEc - flag CWRn - flag NSDans ce cas, nous découvrons que le port 23 a envoyé un paquet de réponse avec les flags ACK et RST définis (réponse typique pour un port fermé selon la rfc793).
Si nous scannons un port ouvert, nous n'obtenons aucune réponse (à moins que le pare-feu ne simule les réponses).
Les autres types de scans TCP peuvent être menés par analogie.
Scan TCP NULL :
cat arp.cache | sx tcp null --json -p 23 192.168.0.171
Scan TCP Xmas :
cat arp.cache | sx tcp xmas --json -p 23 192.168.0.171
Il est possible d'envoyer des paquets TCP avec des flags TCP personnalisés en utilisant l'option --flags.
Envoyons un paquet TCP avec les flags SYN, FIN et ACK définis pour identifier le système d'exploitation distant :
cat arp.cache | sx tcp --flags syn,fin,ack --json -p 23 192.168.0.171
Windows et MacOS ne répondront pas à ce paquet, mais Linux enverra un paquet de réponse avec le flag RST.
Arguments possibles pour l'option --flags :
syn - flag SYNack - flag ACKfin - flag FINrst - flag RSTpsh - flag PSHurg - flag URGece - flag ECEcwr - flag CWRns - flag NSsx peut aider à investiguer les ports UDP ouverts. Le scan UDP exploite la RFC1122 Section 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.
Comme pour les scans TCP, sx retourne des informations sur tous les paquets ICMP de réponse pour le scan UDP. Les informations contiennent l'adresse IP, le type et le code du paquet ICMP définis dans le paquet de réponse.
Par exemple, pour détecter un serveur DNS sur l'hôte, exécutez :
cat arp.cache | sx udp --json -p 53 192.168.0.171
exemple de sortie :
{"scan":"udp","ip":"192.168.0.171","icmp":{"type":3,"code":3}}
Dans ce cas, nous découvrons que l'hôte a envoyé un paquet ICMP de réponse avec le type Destination Unreachable et le code Port Unreachable (réponse typique pour un port fermé selon la rfc1122).
Les pare-feux définissent généralement un code ICMP différent de Port Unreachable et peuvent ainsi être facilement détectés.
Parfois, vous devez limiter la vitesse à laquelle les paquets générés sont envoyés. Cela peut être fait avec l'option --rate.
Par exemple, pour limiter la vitesse à 1 paquet toutes les 5 secondes :
cat arp.cache | sx tcp --rate 1/5s --json -p 22,80,443 192.168.0.171
Parfois, vous devez exclure certaines adresses IP et sous-réseaux du scan. Cela peut être fait avec l'option --exclude. Elle spécifie un fichier avec des IP ou sous-réseaux en notation CIDR à exclure, un par ligne.
Par exemple, pour exclure les adresses RFC 1918, créez un fichier ips.txt avec le contenu suivant :
10.0.0.0/8
172.16.0.0/16
192.168.0.0/16
Vous pouvez également insérer des commentaires et des lignes vides :
# 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
et exécutez un scan avec l'option --exclude ips.txt.
Comme exemple de composition de scan, vous pouvez combiner les scans ARP et TCP SYN pour créer un scanner de ports TCP en direct qui scanne périodiquement l'ensemble du réseau LAN.
Lancez un scan ARP en direct et enregistrez les résultats dans le fichier arp.cache :
sx arp 192.168.0.1/24 --live 10s --json | tee arp.cache
Dans un autre terminal, lancez le scan TCP SYN :
while true; do sx tcp -p 1-65535 -a arp.cache -f arp.cache; sleep 30; done
sx peut détecter les proxies SOCKS5 actifs. Pour scanner, vous devez spécifier une plage IP ou un fichier JSONL avec des paires ip/port.
Par exemple, un scan de plage IP :
sx socks -p 1080 10.0.0.1/16
scan de paires ip/port depuis un fichier avec sortie JSON :
sx socks --json -f ip_ports_file.jsonl
Chaque ligne du fichier d'entrée est une chaîne JSON, qui doit contenir les champs ip et port.
exemple de fichier d'entrée :
{"ip":"10.0.1.1","port":1080}
{"ip":"10.0.2.2","port":1081}
Vous pouvez également spécifier une plage de ports à scanner :
sx socks -p 1080-4567 -f ips_file.jsonl
Dans ce cas, seules les adresses IP seront prises du fichier et le champ port n'est plus nécessaire.
sx help
Les contributions, les problèmes et les demandes de fonctionnalités sont les bienvenus.
Le logo a été conçu par mikhailtsoy.com
Ce projet est sous licence MIT. Voir le fichier LICENSE pour le texte complet de la licence.