def dhcpv6_advertise(rx_if, tx_if, link_local_ip, proxy_ip, server_ip, server_mac, proxy_to_server_mac, interface_id): """Send and check DHCPv6 ADVERTISE proxy packet. :param rx_if: DHCPv6 server interface. :param tx_if: Client interface. :param link_local_ip: Client link-local address. :param proxy_ip: IP address of DHCPv6 proxy server. :param server_ip: IP address of DHCPv6 server. :param server_mac: MAC address of DHCPv6 server. :param proxy_to_server_mac: MAC address of DHCPv6 proxy interface. :param interface_id: ID of proxy interface. :type rx_if: str :type tx_if: str :type link_local_ip: str :type proxy_ip: str :type server_ip: str :type server_mac: str :type proxy_to_server_mac: str :type interface_id: str """ rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] dhcp6_advertise_pkt = Ether(src=server_mac, dst=proxy_to_server_mac) / \ IPv6(src=server_ip, dst=proxy_ip) / \ UDP(sport=UDP_SERVICES.dhcpv6_server, dport=UDP_SERVICES.dhcpv6_client) / \ DHCP6_RelayReply(peeraddr=link_local_ip, linkaddr=proxy_ip) / \ DHCP6OptIfaceId(ifaceid=interface_id) / \ DHCP6OptRelayMsg() / \ DHCP6_Advertise() sent_packets.append(dhcp6_advertise_pkt) txq.send(dhcp6_advertise_pkt) ether = rxq.recv(2) if ether is None: raise RuntimeError('DHCPv6 ADVERTISE timeout') if ether['IPv6'].src != proxy_ip: raise RuntimeError("Source IP address error: {} != {}".format( ether['IPv6'].src, proxy_ip)) print "Source IP address: OK." if not _check_udp_checksum(ether['IPv6']): raise RuntimeError("Checksum error!") print "Checksum: OK." msgtype = _get_dhcpv6_msgtype( ether['IPv6']['UDP']['DHCPv6 Advertise Message'].msgtype) if msgtype != 'ADVERTISE': raise RuntimeError( "Message type error: {} != ADVERTISE".format(msgtype)) print "Message type: OK."
def main(): """Send ICMP echo request and wait for ICMP echo reply. It ignores all other packets.""" args = TrafficScriptArg( ['dst_mac', 'src_mac', 'dst_ip', 'src_ip', 'timeout']) dst_mac = args.get_arg('dst_mac') src_mac = args.get_arg('src_mac') dst_ip = args.get_arg('dst_ip') src_ip = args.get_arg('src_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') timeout = int(args.get_arg('timeout')) wait_step = 1 rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] # Create empty ip ICMP packet if valid_ipv4(src_ip) and valid_ipv4(dst_ip): icmp_request = (Ether(src=src_mac, dst=dst_mac) / IP(src=src_ip, dst=dst_ip) / ICMP()) ip_format = { 'IPType': 'IP', 'ICMP_req': 'ICMP', 'ICMP_rep': 'ICMP', 'Type': 0 } elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): icmp_request = (Ether(src=src_mac, dst=dst_mac) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest()) ip_format = { 'IPType': 'IPv6', 'ICMP_req': 'ICMPv6 Echo Request', 'ICMP_rep': 'ICMPv6 Echo Reply', 'Type': 129 } else: raise ValueError("IP not in correct format") # Send created packet on the interface sent_packets.append(icmp_request) txq.send(icmp_request) for _ in range(1000): icmp_reply = rxq.recv(wait_step, ignore=sent_packets) if icmp_reply is None: timeout -= wait_step if timeout < 0: raise RuntimeError("ICMP echo Rx timeout") elif is_icmp_reply(icmp_reply, ip_format): if address_check(icmp_request, icmp_reply, ip_format): break else: raise RuntimeError("Max packet count limit reached") print "ICMP echo reply received." sys.exit(0)
def main(): """Send IP ICMPv4/ICMPv6 packet from one traffic generator interface to the other one.""" args = TrafficScriptArg( ['src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'icmp_type', 'icmp_code']) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') icmp_type = int(args.get_arg('icmp_type')) icmp_code = int(args.get_arg('icmp_code')) rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] # Create empty ip ICMP packet and add padding before sending if valid_ipv4(src_ip) and valid_ipv4(dst_ip): pkt_raw = (Ether(src=src_mac, dst=dst_mac) / IP(src=src_ip, dst=dst_ip) / ICMP(code=icmp_code, type=icmp_type)) ip_format = 'IP' icmp_format = 'ICMP' elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): pkt_raw = (Ether(src=src_mac, dst=dst_mac) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest(code=icmp_code, type=icmp_type)) ip_format = 'IPv6' icmp_format = 'ICMPv6' else: raise ValueError("IP(s) not in correct format") # Send created packet on one interface and receive on the other sent_packets.append(pkt_raw) txq.send(pkt_raw) ether = rxq.recv(2) # Check whether received packet contains layers Ether, IP and ICMP if ether is None: raise RuntimeError('ICMP echo Rx timeout') if not ether.haslayer(ip_format): raise RuntimeError('Not an IP packet received {0}'.format( ether.__repr__())) # Cannot use haslayer for ICMPv6, every type of ICMPv6 is a separate layer # Next header value of 58 means the next header is ICMPv6 if not ether.haslayer(icmp_format) and ether[ip_format].nh != 58: raise RuntimeError('Not an ICMP packet received {0}'.format( ether.__repr__())) sys.exit(0)
def main(): """Send TCP packet from one traffic generator interface to DUT. :raises: If the IP address is invalid. """ args = TrafficScriptArg([ 'src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'timeout', 'framesize', 'testtype' ]) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') timeout = int(args.get_arg('timeout')) frame_size = int(args.get_arg('framesize')) test_type = args.get_arg('testtype') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] protocol = TCP source_port = sfccon.DEF_SRC_PORT destination_port = sfccon.DEF_DST_PORT ip_version = None if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: raise ValueError("Invalid IP version!") pkt_header = ( Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=int(source_port), dport=int(destination_port))) fsize_no_fcs = frame_size - 4 pad_len = max(0, fsize_no_fcs - len(pkt_header)) pad_data = "A" * pad_len pkt_raw = pkt_header / Raw(load=pad_data) # Send created packet on one interface and receive on the other sent_packets.append(pkt_raw) txq.send(pkt_raw) ether = rxq.recv(timeout) if ether is None: raise RuntimeError("No packet is received!") # let us begin to check the NSH SFC loopback packet VerifyPacket.check_the_nsh_sfc_packet(ether, frame_size, test_type) # we check all the fields about the loopback packet, this test will pass sys.exit(0)
def main(): """Send DHCP DISCOVER packet.""" args = TrafficScriptArg(['tx_src_ip', 'tx_dst_ip']) tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) tx_src_ip = args.get_arg('tx_src_ip') tx_dst_ip = args.get_arg('tx_dst_ip') sent_packets = [] dhcp_discover = Ether(dst="ff:ff:ff:ff:ff:ff") / \ IP(src=tx_src_ip, dst=tx_dst_ip) / \ UDP(sport=UDP_SERVICES.bootpc, dport=UDP_SERVICES.bootps) / \ BOOTP(op=1,) / \ DHCP(options=[("message-type", "discover"), "end"]) sent_packets.append(dhcp_discover) txq.send(dhcp_discover) for _ in range(10): dhcp_discover = rxq.recv(2) if is_discover(dhcp_discover): break else: raise RuntimeError("DHCP DISCOVER Rx timeout") sys.exit(0)
def main(): """Main function.""" args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') pkt_send = (Ether(src=src_mac, dst=dst_mac) / IP(src=src_ip, dst=dst_ip, proto=61)) sent_packets = [] sent_packets.append(pkt_send) txq.send(pkt_send) pkt_recv = rxq.recv(ignore=sent_packets) if pkt_recv is None: raise RuntimeError('Timeout waiting for packet') check_macswap(pkt_send, pkt_recv)
def main(): args = TrafficScriptArg( ['tx_dst_mac', 'rx_dst_mac', 'inner_src_ip', 'inner_dst_ip', 'outer_src_ip', 'outer_dst_ip']) tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') tx_dst_mac = args.get_arg('tx_dst_mac') rx_dst_mac = args.get_arg('rx_dst_mac') inner_src_ip = args.get_arg('inner_src_ip') inner_dst_ip = args.get_arg('inner_dst_ip') outer_src_ip = args.get_arg('outer_src_ip') outer_dst_ip = args.get_arg('outer_dst_ip') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] tx_pkt_raw = Ether(dst=tx_dst_mac) / \ IP(src=inner_src_ip, dst=inner_dst_ip) / \ ICMP() sent_packets.append(tx_pkt_raw) txq.send(tx_pkt_raw) ether = rxq.recv(2) if ether is None: raise RuntimeError("ICMP echo Rx timeout") # Check RX headers if ether.dst != rx_dst_mac: raise RuntimeError("Matching of received destination MAC unsuccessful.") logger.debug("Comparison of received destination MAC: OK.") if ether['IP'].src != outer_src_ip: raise RuntimeError("Matching of received outer source IP unsuccessful.") logger.debug("Comparison of received outer source IP: OK.") if ether['IP'].dst != outer_dst_ip: raise RuntimeError( "Matching of received outer destination IP unsuccessful.") logger.debug("Comparison of received outer destination IP: OK.") if ether['IP'].proto != IP_PROTOS.gre: raise RuntimeError("IP protocol is no GRE.") logger.debug("Comparison of received GRE protocol: OK.") if ether['IP']['GRE']['IP'].src != inner_src_ip: raise RuntimeError("Matching of received inner source IP unsuccessful.") logger.debug("Comparison of received inner source IP: OK.") if ether['IP']['GRE']['IP'].dst != inner_dst_ip: raise RuntimeError( "Matching of received inner destination IP unsuccessful.") logger.debug("Comparison of received inner destination IP: OK.") sys.exit(0)
def dhcp_request(tx_if, rx_if, tx_src_ip, tx_dst_ip, server_ip, proxy_ip, client_ip, client_mac): """Send and check DHCP REQUEST proxy packet.""" rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] dhcp_request = Ether(src=client_mac, dst="ff:ff:ff:ff:ff:ff") / \ IP(src=tx_src_ip, dst=tx_dst_ip) / \ UDP(sport=UDP_SERVICES.bootpc, dport=UDP_SERVICES.bootps) / \ BOOTP(op=1, giaddr=proxy_ip, siaddr=server_ip) / \ DHCP(options=[("message-type", "request"), ("server_id", server_ip), ("requested_addr", client_ip), "end"]) sent_packets.append(dhcp_request) txq.send(dhcp_request) ether = rxq.recv(2) if ether is None: raise RuntimeError('DHCP REQUEST timeout') if ether[IP].dst != server_ip: raise RuntimeError("Destination IP address error.") print "Destination IP address: OK." if ether[IP].src != proxy_ip: raise RuntimeError("Source IP address error.") print "Source IP address: OK." if ether[UDP].dport != UDP_SERVICES.bootps: raise RuntimeError("UDP destination port error.") print "UDP destination port: OK." if ether[UDP].sport != UDP_SERVICES.bootpc: raise RuntimeError("UDP source port error.") print "UDP source port: OK." if ether[BOOTP].siaddr != server_ip: raise RuntimeError("DHCP server IP address error.") print "DHCP server IP address: OK." if ether[DHCP].options[2][1] != client_ip: raise RuntimeError("Requested IP address error.") print "Requested IP address: OK." if ether[DHCP].options[3][0] != 'relay_agent_Information': # option 82 raise RuntimeError("Relay agent information error.") if ether[DHCP].options[0][1] != 3: # 2 - REQUEST message raise RuntimeError("DHCP REQUEST message error.") print "DHCP REQUEST message: OK."
def main(): """Send TCP or UDP packet from one traffic generator interface to the other. """ args = TrafficScriptArg([ 'tx_mac', 'rx_mac', 'src_ip', 'dst_ip', 'protocol', 'source_port', 'destination_port' ]) src_mac = args.get_arg('tx_mac') dst_mac = args.get_arg('rx_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') protocol = args.get_arg('protocol') source_port = args.get_arg('source_port') destination_port = args.get_arg('destination_port') ip_version = None if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: ValueError("Invalid IP version!") if protocol.upper() == 'TCP': protocol = TCP elif protocol.upper() == 'UDP': protocol = UDP else: raise ValueError("Invalid type of protocol!") rxq = RxQueue(rx_if) txq = TxQueue(tx_if) pkt_raw = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=int(source_port), dport=int(destination_port))) txq.send(pkt_raw) ether = rxq.recv(2) if ether is None: raise RuntimeError("TCP/UDP Rx timeout") if 'TCP' in ether: print("TCP packet received.") elif 'UDP' in ether: print("UDP packet received.") else: raise RuntimeError("Not an TCP or UDP packet received {0}".format( ether.__repr__())) sys.exit(0)
def dhcp_offer(rx_if, tx_if, tx_dst_ip, server_ip, proxy_ip, client_ip, server_mac, option_82): """Send and check DHCP OFFER proxy packet.""" rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] dhcp_offer = Ether(src=server_mac, dst="ff:ff:ff:ff:ff:ff") / \ IP(src=server_ip, dst=tx_dst_ip) / \ UDP(sport=UDP_SERVICES.bootps, dport=UDP_SERVICES.bootpc) / \ BOOTP(op=2, yiaddr=client_ip, siaddr=server_ip) / \ DHCP(options= [("message-type", "offer"), ("server_id", server_ip), ("relay_agent_Information", option_82), "end"]) txq.send(dhcp_offer) sent_packets.append(dhcp_offer) ether = rxq.recv(2) if ether is None: raise RuntimeError('DHCP OFFER timeout') if ether[IP].dst != tx_dst_ip: raise RuntimeError("Destination IP address error.") print "Destination IP address: OK." if ether[IP].src != proxy_ip: raise RuntimeError("Source IP address error.") print "Source IP address: OK." if ether[UDP].dport != UDP_SERVICES.bootpc: raise RuntimeError("UDP destination port error.") print "UDP destination port: OK." if ether[UDP].sport != UDP_SERVICES.bootps: raise RuntimeError("UDP source port error.") print "UDP source port: OK." if ether[BOOTP].yiaddr != client_ip: raise RuntimeError("Client IP address error.") print "Client IP address: OK." if ether[BOOTP].siaddr != server_ip: raise RuntimeError("DHCP server IP address error.") print "DHCP server IP address: OK." if ether[DHCP].options[0][1] != 2: # 2 - OFFER message raise RuntimeError("DHCP OFFER message error.") print "DHCP OFFER message OK."
def main(): """Send and receive TCP packet.""" args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'dscp']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') dscp = int(args.get_arg('dscp')) if 6 == ip_address(unicode(src_ip)).version: is_ipv4 = False else: is_ipv4 = True sent_packets = [] if is_ipv4: ip_pkt = (IP(src=src_ip, dst=dst_ip) / TCP()) else: ip_pkt = (IPv6(src=src_ip, dst=dst_ip) / TCP()) pkt_send = (Ether(src=src_mac, dst=dst_mac) / ip_pkt) sent_packets.append(pkt_send) txq.send(pkt_send) while True: pkt_recv = rxq.recv(2, sent_packets) if pkt_recv is None: raise RuntimeError('ICMPv6 echo reply Rx timeout') if pkt_recv.haslayer(ICMPv6ND_NS): # read another packet in the queue if the current one is ICMPv6ND_NS continue else: # otherwise process the current packet break if pkt_recv is None: raise RuntimeError('Rx timeout') if is_ipv4: check_ipv4(pkt_recv, dscp) else: check_ipv6(pkt_recv, dscp) sys.exit(0)
def dhcp_discover(tx_if, rx_if, tx_src_ip, tx_dst_ip, server_ip, proxy_ip, client_mac): """Send and check DHCP DISCOVER proxy packet.""" rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] dhcp_discover = Ether(src=client_mac, dst="ff:ff:ff:ff:ff:ff") / \ IP(src=tx_src_ip, dst=tx_dst_ip) / \ UDP(sport=UDP_SERVICES.bootpc, dport=UDP_SERVICES.bootps) / \ BOOTP(op=1,) / \ DHCP(options=[("message-type", "discover"), "end"]) sent_packets.append(dhcp_discover) txq.send(dhcp_discover) ether = rxq.recv(2) if ether is None: raise RuntimeError('DHCP DISCOVER timeout') if ether[IP].src != proxy_ip: raise RuntimeError("Source IP address error.") print "Source IP address: OK." if ether[IP].dst != server_ip: raise RuntimeError("Destination IP address error.") print "Destination IP address: OK." if ether[UDP].dport != UDP_SERVICES.bootps: raise RuntimeError("UDP destination port error.") print "UDP destination port: OK." if ether[UDP].sport != UDP_SERVICES.bootpc: raise RuntimeError("UDP source port error.") print "UDP source port: OK." if ether[DHCP].options[1][0] != 'relay_agent_Information': # option 82 raise RuntimeError("Relay agent information error.") option_82 = ether[DHCP].options[1][1] if ether[DHCP].options[0][1] != 1: # 1 - DISCOVER message raise RuntimeError("DHCP DISCOVER message error.") print "DHCP DISCOVER message OK." return option_82
def main(): """Send and receive TCP packet.""" args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'dscp']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') dscp = int(args.get_arg('dscp')) if 6 == ip_address(unicode(src_ip)).version: is_ipv4 = False else: is_ipv4 = True sent_packets = [] if is_ipv4: ip_pkt = IP(src=src_ip, dst=dst_ip) / \ TCP() else: ip_pkt = IPv6(src=src_ip, dst=dst_ip) / \ TCP() pkt_send = Ether(src=src_mac, dst=dst_mac) / \ ip_pkt sent_packets.append(pkt_send) txq.send(pkt_send) pkt_recv = rxq.recv(2, sent_packets) if pkt_recv is None: raise RuntimeError('Rx timeout') if is_ipv4: check_ipv4(pkt_recv, dscp) else: check_ipv6(pkt_recv, dscp) sys.exit(0)
def ipv6_ping(src_if, dst_if, src_mac, dst_mac, proxy_to_src_mac, proxy_to_dst_mac, src_ip, dst_ip): """Sends ICMPv6 Echo Request, receive it and send a reply. :param src_if: First TG interface on link to DUT. :param dst_if: Second TG interface on link to DUT. :param src_mac: MAC address of first interface. :param dst_mac: MAC address of second interface. :param proxy_to_src_mac: MAC address of first proxy interface on DUT. :param proxy_to_dst_mac: MAC address of second proxy interface on DUT. :param src_ip: IP address of first interface. :param dst_ip: IP address of second interface. :type src_if: str :type dst_if: str :type src_mac: str :type dst_mac: str :type proxy_to_src_mac: str :type proxy_to_dst_mac: str :type src_ip: str :type dst_ip: str :raises RuntimeError: If a received packet is not correct. """ rxq = RxQueue(dst_if) txq = TxQueue(src_if) icmpv6_ping_pkt = (Ether(src=src_mac, dst=proxy_to_src_mac) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest()) txq.send(icmpv6_ping_pkt) ether = None while True: ether = rxq.recv(3) if not ether: continue if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue in case of ICMPv6ND_NS packet continue else: # otherwise process the current packet break if ether is None: raise RuntimeError('ICMPv6 Echo Request timeout.') try: ether[IPv6]["ICMPv6 Echo Request"] except KeyError: raise RuntimeError("Received packet is not an ICMPv6 Echo Request.") print "ICMP Echo: OK." rxq = RxQueue(src_if) txq = TxQueue(dst_if) icmpv6_ping_pkt = (Ether(src=dst_mac, dst=proxy_to_dst_mac) / IPv6(src=dst_ip, dst=src_ip) / ICMPv6EchoReply()) txq.send(icmpv6_ping_pkt) ether = None while True: ether = rxq.recv(3) if not ether: continue if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue in case of ICMPv6ND_NS packet continue else: # otherwise process the current packet break if ether is None: raise RuntimeError('DHCPv6 SOLICIT timeout') try: ether[IPv6]["ICMPv6 Echo Reply"] except KeyError: raise RuntimeError("Received packet is not an ICMPv6 Echo Reply.") print "ICMP Reply: OK."
def main(): """Send IP ICMP packet from one traffic generator interface to the other.""" args = TrafficScriptArg([ 'tg_src_mac', 'tg_dst_mac', 'src_ip', 'dst_ip', 'dut_if1_mac', 'dut_if2_mac' ], [ 'encaps_tx', 'vlan_tx', 'vlan_outer_tx', 'encaps_rx', 'vlan_rx', 'vlan_outer_rx' ]) tx_src_mac = args.get_arg('tg_src_mac') tx_dst_mac = args.get_arg('dut_if1_mac') rx_dst_mac = args.get_arg('tg_dst_mac') rx_src_mac = args.get_arg('dut_if2_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') encaps_tx = args.get_arg('encaps_tx') vlan_tx = args.get_arg('vlan_tx') vlan_outer_tx = args.get_arg('vlan_outer_tx') encaps_rx = args.get_arg('encaps_rx') vlan_rx = args.get_arg('vlan_rx') vlan_outer_rx = args.get_arg('vlan_outer_rx') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] ip_format = '' pkt_raw = Ether(src=tx_src_mac, dst=tx_dst_mac) if encaps_tx == 'Dot1q': pkt_raw /= Dot1Q(vlan=int(vlan_tx)) elif encaps_tx == 'Dot1ad': pkt_raw.type = 0x88a8 pkt_raw /= Dot1Q(vlan=vlan_outer_tx) pkt_raw /= Dot1Q(vlan=vlan_tx) if valid_ipv4(src_ip) and valid_ipv4(dst_ip): pkt_raw /= IP(src=src_ip, dst=dst_ip) pkt_raw /= ICMP() ip_format = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): pkt_raw /= IPv6(src=src_ip, dst=dst_ip) pkt_raw /= ICMPv6EchoRequest() ip_format = IPv6 else: raise ValueError("IP not in correct format") sent_packets.append(pkt_raw) txq.send(pkt_raw) if tx_if == rx_if: ether = rxq.recv(2, ignore=sent_packets) else: ether = rxq.recv(2) if ether is None: raise RuntimeError("ICMP echo Rx timeout") if rx_dst_mac == ether[Ether].dst and rx_src_mac == ether[Ether].src: logger.trace("MAC matched") else: raise RuntimeError("Matching packet unsuccessful: {0}".format( ether.__repr__())) if encaps_rx == 'Dot1q': if ether[Dot1Q].vlan == int(vlan_rx): logger.trace("VLAN matched") else: raise RuntimeError('Ethernet frame with wrong VLAN tag ({}-' 'received, {}-expected):\n{}'.format( ether[Dot1Q].vlan, vlan_rx, ether.__repr__())) ip = ether[Dot1Q].payload elif encaps_rx == 'Dot1ad': raise NotImplementedError() else: ip = ether.payload if not isinstance(ip, ip_format): raise RuntimeError("Not an IP packet received {0}".format( ip.__repr__())) # Compare data from packets if src_ip == ip.src: logger.trace("Src IP matched") else: raise RuntimeError("Matching Src IP unsuccessful: {} != {}".format( src_ip, ip.src)) if dst_ip == ip.dst: logger.trace("Dst IP matched") else: raise RuntimeError("Matching Dst IP unsuccessful: {} != {}".format( dst_ip, ip.dst)) sys.exit(0)
def main(): """Send VxLAN packet from TG to DUT. :raises: If the IP address is invalid. """ args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'timeout', 'framesize', 'testtype']) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') timeout = max(2, int(args.get_arg('timeout'))) frame_size = int(args.get_arg('framesize')) test_type = args.get_arg('testtype') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] protocol = TCP source_port = SfcCon.DEF_SRC_PORT destination_port = SfcCon.DEF_DST_PORT if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: raise ValueError("Invalid IP version!") innerpkt = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=int(source_port), dport=int(destination_port))) vxlan = '\x08\x00\x00\x00\x00\x00\x01\x00' raw_data = vxlan + str(innerpkt) pkt_header = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / UDP(sport=int(source_port), dport=4789) / Raw(load=raw_data)) fsize_no_fcs = frame_size - 4 pad_len = max(0, fsize_no_fcs - len(pkt_header)) pad_data = "A" * pad_len pkt_raw = pkt_header / Raw(load=pad_data) # Send created packet on one interface and receive on the other sent_packets.append(pkt_raw) txq.send(pkt_raw) while True: ether = rxq.recv(timeout) if ether is None: raise RuntimeError('No packet is received!') if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue if the current one is ICMPv6ND_NS continue else: # otherwise process the current packet break # let us begin to check the proxy outbound packet VerifyPacket.check_the_nsh_sfc_packet(ether, frame_size, test_type) # we check all the fields about the proxy outbound, this test will pass sys.exit(0)
def main(): """Send 100 IP ICMP packets traffic and check if it is divided into two paths.""" args = TrafficScriptArg( ['src_ip', 'dst_ip', 'tg_if1_mac', 'dut_if1_mac', 'dut_if2_mac', 'path_1_mac', 'path_2_mac']) src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tg_if1_mac = args.get_arg('tg_if1_mac') dut_if1_mac = args.get_arg('dut_if1_mac') dut_if2_mac = args.get_arg('dut_if2_mac') path_1_mac = args.get_arg('path_1_mac') path_2_mac = args.get_arg('path_2_mac') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') path_1_counter = 0 path_2_counter = 0 rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] ip_format = '' pkt_raw = '' separator = '' if valid_ipv4(src_ip): separator = '.' elif valid_ipv6(src_ip): separator = ':' else: raise ValueError("Source address not in correct format") src_ip_base = (src_ip.rsplit(separator, 1))[0] + separator for i in range(1, 101): if valid_ipv4(src_ip) and valid_ipv4(dst_ip): pkt_raw = (Ether(src=tg_if1_mac, dst=dut_if1_mac) / IP(src=src_ip_base+str(i), dst=dst_ip) / ICMP()) ip_format = 'IP' elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): pkt_raw = (Ether(src=tg_if1_mac, dst=dut_if1_mac) / IPv6(src=src_ip_base+str(i), dst=dst_ip) / ICMPv6EchoRequest()) ip_format = 'IPv6' else: raise ValueError("IP not in correct format") sent_packets.append(pkt_raw) txq.send(pkt_raw) ether = rxq.recv(2) if ether is None: raise RuntimeError("ICMP echo Rx timeout") if not ether.haslayer(ip_format): raise RuntimeError("Not an IP packet received {0}" .format(ether.__repr__())) if ether['Ethernet'].src != dut_if2_mac: raise RuntimeError("Source MAC address error") if ether['Ethernet'].dst == path_1_mac: path_1_counter += 1 elif ether['Ethernet'].dst == path_2_mac: path_2_counter += 1 else: raise RuntimeError("Destination MAC address error") if (path_1_counter + path_2_counter) != 100: raise RuntimeError("Packet loss: recevied only {} packets of 100 " .format(path_1_counter + path_2_counter)) if path_1_counter == 0: raise RuntimeError("Path 1 error!") if path_2_counter == 0: raise RuntimeError("Path 2 error!") print "Path_1 counter: {}".format(path_1_counter) print "Path_2 counter: {}".format(path_2_counter) sys.exit(0)
def main(): args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') echo_id = 0xa echo_seq = 0x1 sent_packets = [] # send ICMPv6 neighbor advertisement message pkt_send = (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') / IPv6(src=src_ip, dst='ff02::1:ff00:2') / ICMPv6ND_NA(tgt=src_ip, R=0) / ICMPv6NDOptDstLLAddr(lladdr=src_mac)) sent_packets.append(pkt_send) txq.send(pkt_send) # send ICMPv6 echo request pkt_send = (Ether(src=src_mac, dst=dst_mac) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest(id=echo_id, seq=echo_seq)) sent_packets.append(pkt_send) txq.send(pkt_send) # receive ICMPv6 echo reply while True: ether = rxq.recv(2, sent_packets) if ether is None: raise RuntimeError('ICMPv6 echo reply Rx timeout') if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue if the current one is ICMPv6ND_NS continue else: # otherwise process the current packet break if not ether.haslayer(IPv6): raise RuntimeError( 'Unexpected packet with no IPv6 received {0}'.format( ether.__repr__())) ipv6 = ether[IPv6] if not ipv6.haslayer(ICMPv6EchoReply): raise RuntimeError('Unexpected packet with no ICMPv6 echo reply ' 'received {0}'.format(ipv6.__repr__())) icmpv6 = ipv6[ICMPv6EchoReply] # check identifier and sequence number if icmpv6.id != echo_id or icmpv6.seq != echo_seq: raise RuntimeError('Invalid ICMPv6 echo reply received ID {0} seq {1} ' 'should be ID {2} seq {3}'.format( icmpv6.id, icmpv6.seq, echo_id, echo_seq)) # verify checksum cksum = icmpv6.cksum del icmpv6.cksum tmp = ICMPv6EchoReply(str(icmpv6)) if not checksum_equal(tmp.cksum, cksum): raise RuntimeError('Invalid checksum {0} should be {1}'.format( cksum, tmp.cksum)) sys.exit(0)
def main(): """Send IP ICMPv4/ICMPv6 packet from one traffic generator interface to the other one. Dot1q or Dot1ad tagging of the ethernet frame can be set. """ args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip'], ['encaps', 'vlan1', 'vlan2', 'encaps_rx', 'vlan1_rx', 'vlan2_rx']) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') encaps = args.get_arg('encaps') vlan1 = args.get_arg('vlan1') vlan2 = args.get_arg('vlan2') encaps_rx = args.get_arg('encaps_rx') vlan1_rx = args.get_arg('vlan1_rx') vlan2_rx = args.get_arg('vlan2_rx') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] ip_format = '' icmp_format = '' # Create empty ip ICMP packet and add padding before sending if valid_ipv4(src_ip) and valid_ipv4(dst_ip): if encaps == 'Dot1q': pkt_raw = (Ether(src=src_mac, dst=dst_mac) / Dot1Q(vlan=int(vlan1)) / IP(src=src_ip, dst=dst_ip) / ICMP()) elif encaps == 'Dot1ad': pkt_raw = (Ether(src=src_mac, dst=dst_mac, type=0x88A8) / Dot1Q(vlan=int(vlan1), type=0x8100) / Dot1Q(vlan=int(vlan2)) / IP(src=src_ip, dst=dst_ip) / ICMP()) else: pkt_raw = (Ether(src=src_mac, dst=dst_mac) / IP(src=src_ip, dst=dst_ip) / ICMP()) ip_format = IP icmp_format = ICMP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): if encaps == 'Dot1q': pkt_raw = (Ether(src=src_mac, dst=dst_mac) / Dot1Q(vlan=int(vlan1)) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest()) elif encaps == 'Dot1ad': pkt_raw = (Ether(src=src_mac, dst=dst_mac, type=0x88A8) / Dot1Q(vlan=int(vlan1), type=0x8100) / Dot1Q(vlan=int(vlan2)) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest()) else: pkt_raw = (Ether(src=src_mac, dst=dst_mac) / IPv6(src=src_ip, dst=dst_ip) / ICMPv6EchoRequest()) ip_format = IPv6 icmp_format = ICMPv6EchoRequest else: raise ValueError("IP(s) not in correct format") # Send created packet on one interface and receive on the other sent_packets.append(pkt_raw) txq.send(pkt_raw) # Receive ICMP / ICMPv6 echo reply while True: ether = rxq.recv(2,) if ether is None: raise RuntimeError('ICMP echo Rx timeout') if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue if the current one is ICMPv6ND_NS continue else: # otherwise process the current packet break # Check whether received packet contains layers IP/IPv6 and # ICMP/ICMPv6EchoRequest if encaps_rx: if encaps_rx == 'Dot1q': if not vlan1_rx: vlan1_rx = vlan1 if not ether.haslayer(Dot1Q): raise RuntimeError('Not VLAN tagged Eth frame received:\n{0}'. format(ether.__repr__())) elif ether[Dot1Q].vlan != int(vlan1_rx): raise RuntimeError('Ethernet frame with wrong VLAN tag ({}) ' 'received ({} expected):\n{}'. format(ether[Dot1Q].vlan, vlan1_rx, ether.__repr__())) elif encaps_rx == 'Dot1ad': if not vlan1_rx: vlan1_rx = vlan1 if not vlan2_rx: vlan2_rx = vlan2 # TODO raise RuntimeError('Encapsulation {0} not implemented yet.'. format(encaps_rx)) else: raise RuntimeError('Unsupported encapsulation expected: {0}'. format(encaps_rx)) if not ether.haslayer(ip_format): raise RuntimeError('Not an IP/IPv6 packet received:\n{0}'. format(ether.__repr__())) if not ether.haslayer(icmp_format): raise RuntimeError('Not an ICMP/ICMPv6EchoRequest packet received:\n' '{0}'.format(ether.__repr__())) sys.exit(0)
def main(): """Send packets to VPP, then listen for IPFIX flow report. Verify that the correct packet count was reported.""" args = TrafficScriptArg([ 'src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'protocol', 'port', 'count', 'sessions' ]) dst_mac = args.get_arg('dst_mac') src_mac = args.get_arg('src_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') protocol = args.get_arg('protocol') count = int(args.get_arg('count')) sessions = int(args.get_arg('sessions')) txq = TxQueue(tx_if) rxq = RxQueue(tx_if) # generate simple packet based on arguments ip_version = None if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: ValueError("Invalid IP version!") if protocol.upper() == 'TCP': protocol = TCP elif protocol.upper() == 'UDP': protocol = UDP else: raise ValueError("Invalid type of protocol!") packets = [] for x in range(sessions): pkt = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=x, dport=x)) pkt = auto_pad(pkt) packets.append(pkt) # do not print details for sent packets verbose = False print("Sending more than one packet. Details will be filtered for " "all packets sent.") ignore = [] for x in range(sessions): for _ in range(count): txq.send(packets[x], verbose=verbose) ignore.append(packets[x]) # allow scapy to recognize IPFIX headers and templates ipfix = IPFIXHandler() # clear receive buffer while True: pkt = rxq.recv(1, ignore=packets, verbose=verbose) if pkt is None: break data = None ports = [x for x in range(sessions)] # get IPFIX template and data while True: pkt = rxq.recv(5) if pkt is None: raise RuntimeError("RX timeout") if pkt.haslayer("ICMPv6ND_NS"): # read another packet in the queue if the current one is ICMPv6ND_NS continue if pkt.haslayer("IPFIXHeader"): if pkt.haslayer("IPFIXTemplate"): # create or update template for IPFIX data packets ipfix.update_template(pkt) elif pkt.haslayer("IPFIXData"): for x in range(sessions): try: data = pkt.getlayer(IPFIXData, x + 1).fields except AttributeError: raise RuntimeError("Could not find data layer " "#{0}".format(x + 1)) port = verify_data(data, count, src_ip, dst_ip, protocol) if port in ports: ports.remove(port) else: raise RuntimeError("Unexpected or duplicate port {0} " "in flow report.".format(port)) print("All {0} sessions verified " "with packet count {1}.".format(sessions, count)) sys.exit(0) else: raise RuntimeError("Unable to parse IPFIX template " "or data set.") else: raise RuntimeError("Received non-IPFIX packet or IPFIX header was" "not recognized.")
def main(): args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip', 'dst_ip']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') sent_packets = [] # send ICMPv6 neighbor solicitation message pkt_send = (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') / IPv6(src=src_ip, dst='ff02::1:ff00:2') / ICMPv6ND_NS(tgt=dst_ip) / ICMPv6NDOptSrcLLAddr(lladdr=src_mac)) sent_packets.append(pkt_send) txq.send(pkt_send) # receive ICMPv6 neighbor advertisement message ether = rxq.recv(2, sent_packets) if ether is None: raise RuntimeError('ICMPv6 echo reply Rx timeout') if not ether.haslayer(IPv6): raise RuntimeError( 'Unexpected packet with no IPv6 received {0}'.format( ether.__repr__())) ipv6 = ether['IPv6'] if not ipv6.haslayer(ICMPv6ND_NA): raise RuntimeError( 'Unexpected packet with no ICMPv6 ND-NA received {0}'.format( ipv6.__repr__())) icmpv6_na = ipv6['ICMPv6 Neighbor Discovery - Neighbor Advertisement'] # verify target address if icmpv6_na.tgt != dst_ip: raise RuntimeError('Invalid target address {0} should be {1}'.format( icmpv6_na.tgt, dst_ip)) if not icmpv6_na.haslayer(ICMPv6NDOptDstLLAddr): raise RuntimeError( 'Missing Destination Link-Layer Address option in ICMPv6 ' + 'Neighbor Advertisement {0}'.format(icmpv6_na.__repr__())) option = 'ICMPv6 Neighbor Discovery Option - Destination Link-Layer Address' dst_ll_addr = icmpv6_na[option] # verify destination link-layer address field if dst_ll_addr.lladdr != dst_mac: raise RuntimeError('Invalid lladdr {0} should be {1}'.format( dst_ll_addr.lladdr, dst_mac)) # verify checksum cksum = icmpv6_na.cksum del icmpv6_na.cksum tmp = ICMPv6ND_NA(str(icmpv6_na)) if not checksum_equal(tmp.cksum, cksum): raise RuntimeError('Invalid checksum {0} should be {1}'.format( cksum, tmp.cksum)) sys.exit(0)
def main(): """Main function of the script file.""" args = TrafficScriptArg( ['client_mac', 'server_mac', 'server_ip', 'client_ip', 'client_mask'], ['hostname', 'offer_xid']) server_if = args.get_arg('rx_if') server_mac = args.get_arg('server_mac') server_ip = args.get_arg('server_ip') client_mac = args.get_arg('client_mac') client_ip = args.get_arg('client_ip') client_mask = args.get_arg('client_mask') hostname = args.get_arg('hostname') offer_xid = args.get_arg('offer_xid') rx_src_ip = '0.0.0.0' rx_dst_ip = '255.255.255.255' rxq = RxQueue(server_if) txq = TxQueue(server_if) sent_packets = [] for _ in range(10): dhcp_discover = rxq.recv(10) if is_discover(dhcp_discover): break else: raise RuntimeError("DHCP DISCOVER Rx error.") dhcp_offer = Ether(src=server_mac, dst=dhcp_discover.src) dhcp_offer /= IP(src=server_ip, dst="255.255.255.255") dhcp_offer /= UDP(sport=67, dport=68) dhcp_offer /= BOOTP( op=2, # if offer_xid differs from xid value in DHCP DISCOVER # the DHCP OFFER has to be discarded xid=int(offer_xid) if offer_xid else dhcp_discover['BOOTP'].xid, yiaddr=client_ip, siaddr=server_ip, chaddr=dhcp_discover['BOOTP'].chaddr) dhcp_offer_options = [ ("message-type", "offer"), # Option 53 ("subnet_mask", client_mask), # Option 1 ("server_id", server_ip), # Option 54, dhcp server ("lease_time", 43200), # Option 51 "end" ] dhcp_offer /= DHCP(options=dhcp_offer_options) txq.send(dhcp_offer) sent_packets.append(dhcp_offer) max_other_pkts = 10 for _ in range(0, max_other_pkts): dhcp_request = rxq.recv(5, sent_packets) if not dhcp_request: raise RuntimeError("DHCP REQUEST Rx timeout.") if is_request(dhcp_request): break else: raise RuntimeError("Max RX packet limit reached.") if offer_xid: # if offer_xid differs from xid value in DHCP DISCOVER the DHCP OFFER # has to be discarded raise RuntimeError("DHCP REQUEST received. DHCP OFFER with wrong XID " "has not been discarded.") # CHECK ETHER, IP, UDP if dhcp_request.dst != dhcp_discover.dst: raise RuntimeError("Destination MAC error.") print "Destination MAC: OK." if dhcp_request.src != dhcp_discover.src: raise RuntimeError("Source MAC error.") print "Source MAC: OK." if dhcp_request['IP'].dst != rx_dst_ip: raise RuntimeError("Destination IP error.") print "Destination IP: OK." if dhcp_request['IP'].src != rx_src_ip: raise RuntimeError("Source IP error.") print "Source IP: OK." if dhcp_request['IP']['UDP'].dport != UDP_SERVICES.bootps: raise RuntimeError("BOOTPs error.") print "BOOTPs: OK." if dhcp_request['IP']['UDP'].sport != UDP_SERVICES.bootpc: raise RuntimeError("BOOTPc error.") print "BOOTPc: OK." # CHECK BOOTP if dhcp_request['BOOTP'].op != dhcp_discover['BOOTP'].op: raise RuntimeError("BOOTP operation error.") print "BOOTP operation: OK" if dhcp_request['BOOTP'].xid != dhcp_discover['BOOTP'].xid: raise RuntimeError("BOOTP XID error.") print "BOOTP XID: OK" if dhcp_request['BOOTP'].ciaddr != '0.0.0.0': raise RuntimeError("BOOTP ciaddr error.") print "BOOTP ciaddr: OK" ca = dhcp_request['BOOTP'].chaddr[:dhcp_request['BOOTP'].hlen].encode( 'hex') if ca != client_mac.replace(':', ''): raise RuntimeError("BOOTP client hardware address error.") print "BOOTP client hardware address: OK" if dhcp_request['BOOTP'].options != dhcp_discover['BOOTP'].options: raise RuntimeError("DHCP options error.") print "DHCP options: OK" # CHECK DHCP OPTIONS dhcp_options = dhcp_request['DHCP options'].options hn = filter(lambda x: x[0] == 'hostname', dhcp_options) if hostname: try: if hn[0][1] != hostname: raise RuntimeError("Client's hostname doesn't match.") except IndexError: raise RuntimeError("Option list doesn't contain hostname option.") else: if len(hn) != 0: raise RuntimeError("Option list contains hostname option.") print "Option 12 hostname: OK" # Option 50 ra = filter(lambda x: x[0] == 'requested_addr', dhcp_options)[0][1] if ra != client_ip: raise RuntimeError("Option 50 requested_addr error.") print "Option 50 requested_addr: OK" # Option 53 mt = filter(lambda x: x[0] == 'message-type', dhcp_options)[0][1] if mt != 3: # request raise RuntimeError("Option 53 message-type error.") print "Option 53 message-type: OK" # Option 54 sid = filter(lambda x: x[0] == 'server_id', dhcp_options)[0][1] if sid != server_ip: raise RuntimeError("Option 54 server_id error.") print "Option 54 server_id: OK" # Option 55 prl = filter(lambda x: x[0] == 'param_req_list', dhcp_options)[0][1] if prl != '\x01\x1c\x02\x03\x0f\x06w\x0c,/\x1ay*': raise RuntimeError("Option 55 param_req_list error.") print "Option 55 param_req_list: OK" # Option 255 if 'end' not in dhcp_options: raise RuntimeError("end option error.") print "end option: OK" sys.exit(0)
def main(): """Send VxLAN-GPE+NSH packet from TG to DUT. :raises: If the IP address is invalid. """ args = TrafficScriptArg([ 'src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'timeout', 'framesize', 'testtype' ]) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') rx_if = args.get_arg('rx_if') timeout = int(args.get_arg('timeout')) frame_size = int(args.get_arg('framesize')) test_type = args.get_arg('testtype') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] protocol = TCP source_port = sfccon.DEF_SRC_PORT destination_port = sfccon.DEF_DST_PORT ip_version = None if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: raise ValueError("Invalid IP version!") innerpkt = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=int(source_port), dport=int(destination_port))) vxlangpe_nsh = '\x0c\x00\x00\x04\x00\x00\x09\x00\x00\x06' \ '\x01\x03\x00\x00\xb9\xff\xC0\xA8\x32\x4B' \ '\x00\x00\x00\x09\xC0\xA8\x32\x48\x03\x00\x12\xB5' raw_data = vxlangpe_nsh + str(innerpkt) pkt_header = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / UDP(sport=int(source_port), dport=4790) / Raw(load=raw_data)) fsize_no_fcs = frame_size - 4 pad_len = max(0, fsize_no_fcs - len(pkt_header)) pad_data = "A" * pad_len pkt_raw = pkt_header / Raw(load=pad_data) # Send created packet on one interface and receive on the other sent_packets.append(pkt_raw) txq.send(pkt_raw) ether = rxq.recv(2) if ether is None: raise RuntimeError("No packet is received!") # let us begin to check the proxy inbound packet VerifyPacket.check_the_nsh_sfc_packet(ether, frame_size, test_type) # we check all the fields about the proxy inbound, this test will pass sys.exit(0)
def imcpv6nd_solicit(tx_if, src_mac, dst_mac, src_ip, dst_ip): """Send ICMPv6 Neighbor Solicitation packet and expect a response from the proxy. :param tx_if: Interface on TG. :param src_mac: MAC address of TG interface. :param dst_mac: MAC address of proxy interface. :param src_ip: IP address of TG interface. :param dst_ip: IP address of proxied interface. :type tx_if: str :type src_mac: str :type dst_mac: str :type src_ip: str :type dst_ip: str :raises RuntimeError: If the received packet is not correct. """ rxq = RxQueue(tx_if) txq = TxQueue(tx_if) sent_packets = [] icmpv6nd_solicit_pkt = (Ether(src=src_mac, dst=dst_mac) / IPv6(src=src_ip) / ICMPv6ND_NS(tgt=dst_ip)) sent_packets.append(icmpv6nd_solicit_pkt) txq.send(icmpv6nd_solicit_pkt) ether = None for _ in range(5): ether = rxq.recv(3, ignore=sent_packets) if not ether: continue if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue in case of ICMPv6ND_NS packet continue else: # otherwise process the current packet break if ether is None: raise RuntimeError('ICMPv6ND Proxy response timeout.') if ether.src != dst_mac: raise RuntimeError("Source MAC address error: {} != {}".format( ether.src, dst_mac)) print "Source MAC address: OK." if ether.dst != src_mac: raise RuntimeError("Destination MAC address error: {} != {}".format( ether.dst, src_mac)) print "Destination MAC address: OK." if ether[IPv6].src != dst_ip: raise RuntimeError("Source IP address error: {} != {}".format( ether[IPv6].src, dst_ip)) print "Source IP address: OK." if ether[IPv6].dst != src_ip: raise RuntimeError("Destination IP address error: {} != {}".format( ether[IPv6].dst, src_ip)) print "Destination IP address: OK." try: target_addr = ether[IPv6][ICMPv6ND_NA].tgt except (KeyError, AttributeError): raise RuntimeError("Not an ICMPv6ND Neighbor Advertisement packet.") if target_addr != dst_ip: raise RuntimeError( "ICMPv6 field 'Target address' error: {} != {}".format( target_addr, dst_ip)) print "Target address field: OK."
def main(): """Send and receive IPsec packet.""" args = TrafficScriptArg([ 'src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'crypto_alg', 'crypto_key', 'integ_alg', 'integ_key', 'l_spi', 'r_spi' ], ['src_tun', 'dst_tun']) rxq = RxQueue(args.get_arg('rx_if')) txq = TxQueue(args.get_arg('tx_if')) src_mac = args.get_arg('src_mac') dst_mac = args.get_arg('dst_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') crypto_alg = args.get_arg('crypto_alg') crypto_key = args.get_arg('crypto_key') integ_alg = args.get_arg('integ_alg') integ_key = args.get_arg('integ_key') l_spi = int(args.get_arg('l_spi')) r_spi = int(args.get_arg('r_spi')) src_tun = args.get_arg('src_tun') dst_tun = args.get_arg('dst_tun') is_ipv4 = True if 6 == ip_address(unicode(src_ip)).version: is_ipv4 = False tunnel_out = None tunnel_in = None if src_tun and dst_tun: if is_ipv4: tunnel_out = IP(src=src_tun, dst=dst_tun) tunnel_in = IP(src=dst_tun, dst=src_tun) else: tunnel_out = IPv6(src=src_tun, dst=dst_tun) tunnel_in = IPv6(src=dst_tun, dst=src_tun) else: src_tun = src_ip dst_tun = dst_ip sa_in = SecurityAssociation(ESP, spi=r_spi, crypt_algo=crypto_alg, crypt_key=crypto_key, auth_algo=integ_alg, auth_key=integ_key, tunnel_header=tunnel_in) sa_out = SecurityAssociation(ESP, spi=l_spi, crypt_algo=crypto_alg, crypt_key=crypto_key, auth_algo=integ_alg, auth_key=integ_key, tunnel_header=tunnel_out) sent_packets = [] if is_ipv4: ip_pkt = IP(src=src_ip, dst=dst_ip) / \ ICMP() ip_pkt = IP(str(ip_pkt)) else: ip_pkt = IPv6(src=src_ip, dst=dst_ip) / \ ICMPv6EchoRequest() ip_pkt = IPv6(str(ip_pkt)) e_pkt = sa_out.encrypt(ip_pkt) pkt_send = Ether(src=src_mac, dst=dst_mac) / \ e_pkt sent_packets.append(pkt_send) txq.send(pkt_send) pkt_recv = rxq.recv(2, sent_packets) if pkt_recv is None: raise RuntimeError('ESP packet Rx timeout') if is_ipv4: check_ipv4(pkt_recv, src_tun, dst_ip, src_ip, sa_in) else: check_ipv6(pkt_recv, src_tun, dst_ip, src_ip, sa_in) sys.exit(0)
def ipv6_ping(src_if, dst_if, src_mac, dst_mac, proxy_to_src_mac, proxy_to_dst_mac, src_ip, dst_ip): """Sends ICMPv6 Echo Request, receive it and send a reply. :param src_if: First TG interface on link to DUT. :param dst_if: Second TG interface on link to DUT. :param src_mac: MAC address of first interface. :param dst_mac: MAC address of second interface. :param proxy_to_src_mac: MAC address of first proxy interface on DUT. :param proxy_to_dst_mac: MAC address of second proxy interface on DUT. :param src_ip: IP address of first interface. :param dst_ip: IP address of second interface. :type src_if: str :type dst_if: str :type src_mac: str :type dst_mac: str :type proxy_to_src_mac: str :type proxy_to_dst_mac: str :type src_ip: str :type dst_ip: str :raises RuntimeError: If a received packet is not correct. """ rxq = RxQueue(dst_if) txq = TxQueue(src_if) icmpv6_ping_pkt = \ Ether(src=src_mac, dst=proxy_to_src_mac) / \ IPv6(src=src_ip, dst=dst_ip) / \ ICMPv6EchoRequest() txq.send(icmpv6_ping_pkt) ether = None for _ in range(5): pkt = rxq.recv(3) if pkt is not None: ether = pkt break if ether is None: raise RuntimeError('ICMPv6 Echo Request timeout.') try: ether["IPv6"]["ICMPv6 Echo Request"] except KeyError: raise RuntimeError("Received packet is not an ICMPv6 Echo Request.") print "ICMP Echo: OK." rxq = RxQueue(src_if) txq = TxQueue(dst_if) icmpv6_ping_pkt = \ Ether(src=dst_mac, dst=proxy_to_dst_mac) / \ IPv6(src=dst_ip, dst=src_ip) / \ ICMPv6EchoReply() txq.send(icmpv6_ping_pkt) ether = None for _ in range(5): pkt = rxq.recv(3) if pkt is not None: ether = pkt break if ether is None: raise RuntimeError('DHCPv6 SOLICIT timeout') try: ether["IPv6"]["ICMPv6 Echo Reply"] except KeyError: raise RuntimeError("Received packet is not an ICMPv6 Echo Reply.") print "ICMP Reply: OK."
def main(): """Send packets to VPP, then listen for IPFIX flow report. Verify that the correct packet count was reported.""" args = TrafficScriptArg([ 'src_mac', 'dst_mac', 'src_ip', 'dst_ip', 'protocol', 'port', 'count' ]) dst_mac = args.get_arg('dst_mac') src_mac = args.get_arg('src_mac') src_ip = args.get_arg('src_ip') dst_ip = args.get_arg('dst_ip') tx_if = args.get_arg('tx_if') protocol = args.get_arg('protocol') source_port = int(args.get_arg('port')) destination_port = int(args.get_arg('port')) count = int(args.get_arg('count')) txq = TxQueue(tx_if) rxq = RxQueue(tx_if) # generate simple packet based on arguments if valid_ipv4(src_ip) and valid_ipv4(dst_ip): ip_version = IP elif valid_ipv6(src_ip) and valid_ipv6(dst_ip): ip_version = IPv6 else: raise ValueError("Invalid IP version!") if protocol.upper() == 'TCP': protocol = TCP elif protocol.upper() == 'UDP': protocol = UDP else: raise ValueError("Invalid type of protocol!") pkt_raw = (Ether(src=src_mac, dst=dst_mac) / ip_version(src=src_ip, dst=dst_ip) / protocol(sport=int(source_port), dport=int(destination_port))) # do not print details for sent packets when sending more than one if count > 1: verbose = False print("Sending more than one packet. Details will be filtered for " "all packets sent.") else: verbose = True pkt_pad = auto_pad(pkt_raw) ignore = [] for _ in range(count): txq.send(pkt_pad, verbose=verbose) ignore.append(pkt_pad) # allow scapy to recognize IPFIX headers and templates ipfix = IPFIXHandler() data = None # get IPFIX template and data while True: pkt = rxq.recv(10, ignore=ignore, verbose=verbose) if pkt is None: raise RuntimeError("RX timeout") if pkt.haslayer("ICMPv6ND_NS"): # read another packet in the queue if the current one is ICMPv6ND_NS continue if pkt.haslayer("IPFIXHeader"): if pkt.haslayer("IPFIXTemplate"): # create or update template for IPFIX data packets ipfix.update_template(pkt) elif pkt.haslayer("IPFIXData"): data = pkt.getlayer(IPFIXData).fields break else: raise RuntimeError("Unable to parse IPFIX set after header.") else: raise RuntimeError("Received non-IPFIX packet or IPFIX header " "not recognized.") # verify packet count if data["packetTotalCount"] != count: raise RuntimeError("IPFIX reported wrong packet count. Count was {0}," "but should be {1}".format(data["packetTotalCount"], count)) # verify IP addresses keys = data.keys() err = "{0} mismatch. Packets used {1}, but were classified as {2}." if ip_version == IP: if "IPv4_src" in keys: if data["IPv4_src"] != src_ip: raise RuntimeError( err.format("Source IP", src_ip, data["IPv4_src"])) if "IPv4_dst" in keys: if data["IPv4_dst"] != dst_ip: raise RuntimeError( err.format("Destination IP", dst_ip, data["IPv4_dst"])) else: if "IPv6_src" in keys: if data["IPv6_src"] != src_ip: raise RuntimeError( err.format("Source IP", src_ip, data["IPv6_src"])) if "IPv6_dst" in keys: if data["IPv6_dst"] != dst_ip: raise RuntimeError( err.format("Source IP", src_ip, data["IPv6_dst"])) # verify port numbers for item in ("src_port", "tcp_src_port", "udp_src_port"): try: if int(data[item]) != source_port: raise RuntimeError( err.format("Source port", source_port, data[item])) except KeyError: pass for item in ("dst_port", "tcp_dst_port", "udp_dst_port"): try: if int(data[item]) != destination_port: raise RuntimeError( err.format("Source port", destination_port, data[item])) except KeyError: pass # verify protocol ID if "Protocol_ID" in keys: if protocol == TCP and int(data["Protocol_ID"]) != 6: raise RuntimeError("TCP Packets were classified as not TCP.") if protocol == UDP and int(data["Protocol_ID"]) != 17: raise RuntimeError("UDP Packets were classified as not UDP.") sys.exit(0)
def main(): """Send Router Solicitation packet, check if the received response\ is a Router Advertisement packet and verify.""" args = TrafficScriptArg(['src_mac', 'dst_mac', 'src_ip']) router_mac = args.get_arg('dst_mac') src_mac = args.get_arg('src_mac') src_ip = args.get_arg('src_ip') if not src_ip: src_ip = mac_to_ipv6_linklocal(src_mac) tx_if = args.get_arg('tx_if') txq = TxQueue(tx_if) rxq = RxQueue(tx_if) pkt_raw = (Ether(src=src_mac, dst='33:33:00:00:00:02') / IPv6(src=src_ip, dst='ff02::2') / ICMPv6ND_RS()) sent_packets = [pkt_raw] txq.send(pkt_raw) while True: ether = rxq.recv(2, sent_packets) if ether is None: raise RuntimeError('ICMP echo Rx timeout') if ether.haslayer(ICMPv6ND_NS): # read another packet in the queue if the current one is ICMPv6ND_NS continue else: # otherwise process the current packet break # Check whether received packet contains layer RA and check other values if ether.src != router_mac: raise RuntimeError('Packet source MAC ({0}) does not match router MAC ' '({1}).'.format(ether.src, router_mac)) if ether.dst != src_mac: raise RuntimeError('Packet destination MAC ({0}) does not match RS ' 'source MAC ({1}).'.format(ether.dst, src_mac)) if not ether.haslayer(ICMPv6ND_RA): raise RuntimeError('Not an RA packet received {0}'.format( ether.__repr__())) src_address = ipaddress.IPv6Address(unicode(ether['IPv6'].src)) dst_address = ipaddress.IPv6Address(unicode(ether['IPv6'].dst)) router_link_local = ipaddress.IPv6Address( unicode(mac_to_ipv6_linklocal(router_mac))) rs_src_address = ipaddress.IPv6Address(unicode(src_ip)) if src_address != router_link_local: raise RuntimeError('Packet source address ({0}) does not match link ' 'local address({1})'.format(src_address, router_link_local)) if dst_address != rs_src_address: raise RuntimeError('Packet destination address ({0}) does not match ' 'RS source address ({1}).'.format( dst_address, rs_src_address)) if ether['IPv6'].hlim != 255: raise RuntimeError('Hop limit not correct: {0}!=255'.format( ether['IPv6'].hlim)) ra_code = ether[ICMPv6ND_RA].code if ra_code != 0: raise RuntimeError('ICMP code: {0} not correct. '.format(ra_code)) sys.exit(0)
def main(): # pylint: disable=too-many-statements, too-many-locals """Main function of the script file.""" args = TrafficScriptArg([ 'tx_dst_mac', 'tx_src_mac', 'tx_dst_ipv6', 'tx_src_ipv6', 'tx_dst_ipv4', 'tx_src_ipv4', 'tx_src_udp_port', 'rx_dst_mac', 'rx_src_mac' ]) rx_if = args.get_arg('rx_if') tx_if = args.get_arg('tx_if') tx_src_mac = args.get_arg('tx_src_mac') tx_dst_mac = args.get_arg('tx_dst_mac') tx_dst_ipv6 = args.get_arg('tx_dst_ipv6') tx_src_ipv6 = args.get_arg('tx_src_ipv6') tx_dst_ipv4 = args.get_arg('tx_dst_ipv4') tx_src_ipv4 = args.get_arg('tx_src_ipv4') tx_src_udp_port = int(args.get_arg('tx_src_udp_port')) tx_dst_udp_port = 20000 rx_dst_mac = args.get_arg('rx_dst_mac') rx_src_mac = args.get_arg('rx_src_mac') rxq = RxQueue(rx_if) txq = TxQueue(tx_if) sent_packets = [] # Create empty UDP datagram in IPv4 and IPv6 tx_pkt = (Ether(dst=tx_dst_mac, src=tx_src_mac) / IPv6(src=tx_src_ipv6, dst=tx_dst_ipv6) / IP(src=tx_src_ipv4, dst=tx_dst_ipv4) / UDP(sport=tx_src_udp_port, dport=tx_dst_udp_port)) txq.send(tx_pkt) sent_packets.append(tx_pkt) for _ in range(5): pkt = rxq.recv(2) if _is_udp_in_ipv4(pkt): ether = pkt break else: raise RuntimeError("UDP in IPv4 Rx error.") # check ethernet if ether.dst != rx_dst_mac: raise RuntimeError("Destination MAC error {} != {}.".format( ether.dst, rx_dst_mac)) print "Destination MAC: OK." if ether.src != rx_src_mac: raise RuntimeError("Source MAC error {} != {}.".format( ether.src, rx_src_mac)) print "Source MAC: OK." ipv4 = ether.payload # check ipv4 if ipv4.dst != tx_dst_ipv4: raise RuntimeError("Destination IPv4 error {} != {}.".format( ipv4.dst, tx_dst_ipv4)) print "Destination IPv4: OK." if ipv4.src != tx_src_ipv4: raise RuntimeError("Source IPv4 error {} != {}.".format( ipv4.src, tx_src_ipv4)) print "Source IPv4: OK." if ipv4.proto != 17: # UDP raise RuntimeError("IPv4 protocol error {} != UDP.".format(ipv4.proto)) print "IPv4 protocol: OK." udp = ipv4.payload # check udp if udp.dport != tx_dst_udp_port: raise RuntimeError("UDP dport error {} != {}.".format( udp.dport, tx_dst_udp_port)) print "UDP dport: OK." if udp.sport != tx_src_udp_port: raise RuntimeError("UDP sport error {} != {}.".format( udp.sport, tx_src_udp_port)) print "UDP sport: OK." sys.exit(0)
def main(): """Main function of the script file.""" args = TrafficScriptArg( ['server_mac', 'server_ip', 'client_ip', 'client_mask', 'lease_time']) server_if = args.get_arg('rx_if') server_mac = args.get_arg('server_mac') server_ip = args.get_arg('server_ip') client_ip = args.get_arg('client_ip') client_mask = args.get_arg('client_mask') lease_time = int(args.get_arg('lease_time')) rxq = RxQueue(server_if) txq = TxQueue(server_if) sent_packets = [] for _ in range(10): dhcp_discover = rxq.recv(10) if is_discover(dhcp_discover): break else: raise RuntimeError("DHCP DISCOVER Rx error.") dhcp_offer = Ether(src=server_mac, dst=dhcp_discover.src) dhcp_offer /= IP(src=server_ip, dst="255.255.255.255") dhcp_offer /= UDP(sport=67, dport=68) dhcp_offer /= BOOTP(op=2, xid=dhcp_discover['BOOTP'].xid, yiaddr=client_ip, siaddr=server_ip, chaddr=dhcp_discover['BOOTP'].chaddr) dhcp_offer_options = [ ("message-type", "offer"), # Option 53 ("subnet_mask", client_mask), # Option 1 ("server_id", server_ip), # Option 54, dhcp server ("lease_time", lease_time), # Option 51 "end" ] dhcp_offer /= DHCP(options=dhcp_offer_options) txq.send(dhcp_offer) sent_packets.append(dhcp_offer) max_other_pkts = 10 for _ in range(0, max_other_pkts): dhcp_request = rxq.recv(5, sent_packets) if not dhcp_request: raise RuntimeError("DHCP REQUEST Rx timeout.") if is_request(dhcp_request): break else: raise RuntimeError("Max RX packet limit reached.") # Send dhcp ack dhcp_ack = Ether(src=server_mac, dst=dhcp_request.src) dhcp_ack /= IP(src=server_ip, dst="255.255.255.255") dhcp_ack /= UDP(sport=67, dport=68) dhcp_ack /= BOOTP(op=2, xid=dhcp_request['BOOTP'].xid, yiaddr=client_ip, siaddr=server_ip, flags=dhcp_request['BOOTP'].flags, chaddr=dhcp_request['BOOTP'].chaddr) dhcp_ack_options = [ ("message-type", "ack"), # Option 53. 5: ACK, 6: NAK ("subnet_mask", client_mask), # Option 1 ("server_id", server_ip), # Option 54, dhcp server ("lease_time", lease_time), # Option 51, "end" ] dhcp_ack /= DHCP(options=dhcp_ack_options) txq.send(dhcp_ack) sent_packets.append(dhcp_ack) sys.exit(0)