def create_eth_packet_with_vlan(pktlen=60, dl_src=None, dl_dst=None, dl_vlan=0, dl_vlan_pcp=2, dl_vlan_cfi=0): print "fields are: dst: %s, src: %s, prio: %d, id: %d, vlan: %d" % ( dl_dst, dl_src, dl_vlan_pcp, dl_vlan_cfi, dl_vlan) if dl_dst is None or dl_src is None: return None if MINSIZE > pktlen: pktlen = MINSIZE pkt = scapy.Ether(type=0x800, dst='ff:ff:ff:ff:ff:ff', src='00:00:00:00:00:01') / scapy.Dot1Q( vlan=int(dl_vlan)) / scapy.Dot1Q( vlan=int(dl_vlan)) / "TEST!!!!!!!!" # create the packet data (junk data) pkt = pkt / ("v" * (pktlen - len(pkt))) print "send the following vlan packet: %s" % (str( scapy.Ether(str(pkt)).show())) print pkt.payload return pkt
def qinq_tcp_packet(pktlen=100, eth_dst='00:01:02:03:04:05', eth_src='00:06:07:08:09:0a', dl_vlan_outer=20, dl_vlan_pcp_outer=0, dl_vlan_cfi_outer=0, vlan_vid=10, vlan_pcp=0, dl_vlan_cfi=0, ip_src='192.168.0.1', ip_dst='192.168.0.2', ip_tos=0, ip_ttl=64, tcp_sport=1234, tcp_dport=80, ip_ihl=None, ip_options=False): """ Return a doubly tagged dataplane TCP packet Supports a few parameters: @param len Length of packet in bytes w/o CRC @param eth_dst Destinatino MAC @param eth_src Source MAC @param dl_vlan_outer Outer VLAN ID @param dl_vlan_pcp_outer Outer VLAN priority @param dl_vlan_cfi_outer Outer VLAN cfi bit @param vlan_vid Inner VLAN ID @param vlan_pcp VLAN priority @param dl_vlan_cfi VLAN cfi bit @param ip_src IP source @param ip_dst IP destination @param ip_tos IP ToS @param tcp_dport TCP destination port @param ip_sport TCP source port Generates a TCP request. Users shouldn't assume anything about this packet other than that it is a valid ethernet/IP/TCP frame. """ if MINSIZE > pktlen: pktlen = MINSIZE # Note Dot1Q.id is really CFI pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \ scapy.Dot1Q(prio=dl_vlan_pcp_outer, id=dl_vlan_cfi_outer, vlan=dl_vlan_outer)/ \ scapy.Dot1Q(prio=vlan_pcp, id=dl_vlan_cfi, vlan=vlan_vid)/ \ scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ttl=ip_ttl, ihl=ip_ihl)/ \ scapy.TCP(sport=tcp_sport, dport=tcp_dport) pkt = pkt / ("D" * (pktlen - len(pkt))) return pkt
def simple_tcp_packet(pktlen=100, dl_dst='00:01:02:03:04:05', dl_src='00:06:07:08:09:0a', dl_vlan_enable=False, dl_vlan=0, dl_vlan_pcp=0, dl_vlan_cfi=0, ip_src='192.168.0.1', ip_dst='192.168.0.2', ip_tos=0, tcp_sport=1234, tcp_dport=80, ip_ihl=None, ip_options=False): """ Return a simple dataplane TCP packet Supports a few parameters: @param len Length of packet in bytes w/o CRC @param dl_dst Destinatino MAC @param dl_src Source MAC @param dl_vlan_enable True if the packet is with vlan, False otherwise @param dl_vlan VLAN ID @param dl_vlan_pcp VLAN priority @param ip_src IP source @param ip_dst IP destination @param ip_tos IP ToS @param tcp_dport TCP destination port @param ip_sport TCP source port Generates a simple TCP request. Users shouldn't assume anything about this packet other than that it is a valid ethernet/IP/TCP frame. """ if MINSIZE > pktlen: pktlen = MINSIZE # Note Dot1Q.id is really CFI if (dl_vlan_enable): pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)/ \ scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl)/ \ scapy.TCP(sport=tcp_sport, dport=tcp_dport) else: if not ip_options: pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl)/ \ scapy.TCP(sport=tcp_sport, dport=tcp_dport) else: pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl, options=ip_options)/ \ scapy.TCP(sport=tcp_sport, dport=tcp_dport) pkt = pkt / ("D" * (pktlen - len(pkt))) #print pkt.show() #print scapy.Ether(str(pkt)).show() return pkt
def addVlanToPacket(self, pkt, vlanValue): """ This function push the received vlan tag to the received packet """ # gets the first layer of the current packet layer = pkt.firstlayer() # loop over the layers while not isinstance(layer, scapy.NoPayload): if 'chksum' in layer.default_fields: del layer.chksum if (type(layer) is scapy.Ether): # adjust ether type layer.type = 33024 # 0x8100 # add 802.1q layer between Ether and IP dot1q = scapy.Dot1Q(vlan=vlanValue) dot1q.add_payload(layer.payload) layer.remove_payload() layer.add_payload(dot1q) layer = dot1q # advance to the next layer layer = layer.payload
def simple_ipv6_packet(pktlen=100, dl_dst='00:01:02:03:04:05', dl_src='00:06:07:08:09:0a', dl_vlan_enable=False, dl_vlan=0, dl_vlan_pcp=0, dl_vlan_cfi=0, ip_src='fe80::2420:52ff:fe8f:5189', ip_dst='fe80::2420:52ff:fe8f:5190', ip_tos=0, tcp_sport=0, tcp_dport=0, EH = False, EHpkt = scapy.IPv6ExtHdrDestOpt() ): """ Return a simple dataplane IPv6 packet Supports a few parameters: @param len Length of packet in bytes w/o CRC @param dl_dst Destinatino MAC @param dl_src Source MAC @param dl_vlan_enable True if the packet is with vlan, False otherwise @param dl_vlan VLAN ID @param dl_vlan_pcp VLAN priority @param ip_src IPv6 source @param ip_dst IPv6 destination @param ip_tos IP ToS @param tcp_dport TCP destination port @param ip_sport TCP source port Generates a simple TCP request. Users shouldn't assume anything about this packet other than that it is a valid ethernet/IP/TCP frame. """ # Note Dot1Q.id is really CFI if (dl_vlan_enable): pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan)/ \ scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos) else: pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.IPv6(src=ip_src, dst=ip_dst) # Add IPv6 Extension Headers if EH: pkt = pkt / EHpkt if (tcp_sport >0 and tcp_dport >0): pkt = pkt / scapy.TCP(sport=tcp_sport, dport=tcp_dport) pktlen = len(pkt) # why?? pkt = pkt/("D" * (pktlen - len(pkt))) return pkt
def make_VLAN_hdr(vlan=None, id=None, prio=None, **kwargs): hdr = scapy.Dot1Q() if vlan: hdr.vlan = vlan if id: hdr.id = id if prio: hdr.prio = prio return hdr
def gen_packet(vid): eth = scapy.Ether(src='02:1e:67:9f:4d:ae', dst='06:16:3e:1b:72:32') vlan1 = scapy.Dot1AD(vlan=vid) vlan2 = scapy.Dot1Q(vlan=vid) ip = scapy.IP() udp = scapy.UDP(sport=10001, dport=10002) payload = 'truculence' single_tag = eth / vlan2 / ip / udp / payload double_tag = eth / vlan1 / vlan2 / ip / udp / payload return single_tag, double_tag
def get_packet(self, vlan): normal_data = 'Nailgun:{iface} 1'.format(iface=self.iface) p = scapy.Ether(src='64:0b:36:0e:0a:b7', dst="ff:ff:ff:ff:ff:ff") if int(vlan) > 0: p = p / scapy.Dot1Q(vlan=int(vlan)) message_len = len(normal_data) + 8 p = p / scapy.IP(src=self.config['src'], dst=self.config['dst']) p = p / scapy.UDP(sport=self.config['sport'], dport=self.config['dport'], len=message_len) / normal_data return p
def simple_icmp_packet(pktlen=60, eth_dst='00:01:02:03:04:05', eth_src='00:06:07:08:09:0a', dl_vlan_enable=False, vlan_vid=0, vlan_pcp=0, ip_src='192.168.0.1', ip_dst='192.168.0.2', ip_tos=0, ip_ttl=64, icmp_type=8, icmp_code=0): """ Return a simple ICMP packet Supports a few parameters: @param len Length of packet in bytes w/o CRC @param eth_dst Destinatino MAC @param eth_src Source MAC @param dl_vlan_enable True if the packet is with vlan, False otherwise @param vlan_vid VLAN ID @param vlan_pcp VLAN priority @param ip_src IP source @param ip_dst IP destination @param ip_tos IP ToS @param ip_ttl IP TTL @param icmp_type ICMP type @param icmp_code ICMP code Generates a simple ICMP ECHO REQUEST. Users shouldn't assume anything about this packet other than that it is a valid ethernet/ICMP frame. """ if MINSIZE > pktlen: pktlen = MINSIZE if (dl_vlan_enable): pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \ scapy.Dot1Q(prio=vlan_pcp, id=0, vlan=vlan_vid)/ \ scapy.IP(src=ip_src, dst=ip_dst, ttl=ip_ttl, tos=ip_tos)/ \ scapy.ICMP(type=icmp_type, code=icmp_code) else: pkt = scapy.Ether(dst=eth_dst, src=eth_src)/ \ scapy.IP(src=ip_src, dst=ip_dst, ttl=ip_ttl, tos=ip_tos)/ \ scapy.ICMP(type=icmp_type, code=icmp_code) pkt = pkt / ("0" * (pktlen - len(pkt))) return pkt
def _sendp(self, iface, vlan): try: data = str(''.join((self.config['cookie'], iface, ' ', self.config['uid']))) p = scapy.Ether(src=self._get_iface_mac(iface), dst="ff:ff:ff:ff:ff:ff") if vlan > 0: p = p / scapy.Dot1Q(vlan=vlan) p = p / scapy.IP(src=self.config['src'], dst=self.config['dst']) p = p / scapy.UDP(sport=self.config['sport'], dport=self.config['dport']) / data scapy.sendp(p, iface=iface) except socket.error as e: self.logger.error("Socket error: %s, %s", e, iface)
def PrepareHALRequestSpec(self, req_spec): # # For now we only have Ah Requests. In future we need to make sure what kind # of spec it is. # if not self.lqp.svc == 3: return logger.info("PrepareHALRequestSpec:: RDMA Session: %s Session: %s " "Remote QP: %s Local QP: %s" %\ (self.GID(), self.session.GID(), self.rqp.GID(), self.lqp.GID())) if (GlobalOptions.dryrun): return logger.info("RdmaAhCreate:: src_ip: %s dst_ip: %s src_mac: %s dst_mac: %s proto: %s " "sport: %s dport: %s ah_handle: %d isipv6: %d" %\ (self.session.initiator.addr.get(), self.session.responder.addr.get(), self.session.initiator.ep.macaddr.get(), self.session.responder.ep.macaddr.get(), self.session.iflow.proto, self.session.iflow.sport, self.session.iflow.dport, self.ah_handle, self.session.IsIPV6())) EthHdr = scapy.Ether(src=self.session.initiator.ep.macaddr.get(), dst=self.session.responder.ep.macaddr.get()) Dot1qHdr = scapy.Dot1Q( vlan=self.session.initiator.ep.intf.encap_vlan_id, prio=self.session.iflow.txqos.cos) if self.session.IsIPV6(): IpHdr = scapy.IPv6(src=self.session.initiator.addr.get(), dst=self.session.responder.addr.get(), tc=self.session.iflow.txqos.dscp, plen=0) else: IpHdr = scapy.IP( src=self.session.initiator.addr.get(), dst=self.session.responder.addr.get(), tos=0, # keep tos = 0 to not trigger ecn mark len=0, chksum=0) UdpHdr = scapy.UDP(sport=self.session.iflow.sport, dport=self.session.iflow.dport, len=0, chksum=0) req_spec.hw_lif_id = self.lqp.pd.ep.intf.lif.hw_lif_id req_spec.header_template = bytes(EthHdr / Dot1qHdr / IpHdr / UdpHdr) req_spec.ahid = self.ah_handle return
def gen_packet(proto, src_ip, dst_ip, src_port=10001, dst_port=10002, src_mac='02:1e:67:9f:4d:ae', dst_mac='ae:34:2e:16:b8:cd', vlan_tci=None): eth = scapy.Ether(src=src_mac, dst=dst_mac) ip = scapy.IP(src=src_ip, dst=dst_ip) udp = proto(sport=src_port, dport=dst_port) payload = 'helloworld' if vlan_tci is None: pkt = eth / ip / udp / payload else: dotq = scapy.Dot1Q(vlan=vlan_tci) pkt = eth / dotq / ip / udp / payload return bytes(pkt)
def test_vlan(self): import loxi.of12 as ofp self.maxDiff = None pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a')/ \ scapy.Dot1Q(vlan=50, prio=5)/ \ scapy.IP(src='192.168.0.1', dst='192.168.0.2', tos=2 | (32 << 2), ttl=64)/ \ scapy.TCP(sport=1234, dport=80) expected = [ ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]), ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]), ofp.oxm.eth_type(0x0800), ofp.oxm.vlan_vid(50), ofp.oxm.vlan_pcp(5), ofp.oxm.ip_proto(6), ofp.oxm.ip_dscp(32), ofp.oxm.ip_ecn(2), ofp.oxm.ipv4_src(0xc0a80001), ofp.oxm.ipv4_dst(0xc0a80002), ofp.oxm.tcp_src(1234), ofp.oxm.tcp_dst(80) ] result = parse.packet_to_flow_match_v3(pkt).oxm_list self.assertEquals([x.show() for x in expected], [x.show() for x in result])
def simplePacket(pktlen=100, dl_dst='00:01:02:03:04:05', dl_src='00:06:07:08:09:0a', dl_vlan=0xffff, dl_vlan_pcp=0, dl_vlan_cfi=0, dl_type=ETHERTYPE_IP, nw_src='192.168.0.1', nw_dst='192.168.0.2', nw_tos=0, nw_proto=socket.IPPROTO_TCP, tp_src=1234, tp_dst=80): """ Return a simple packet Users shouldn't assume anything about this packet other than that it is a valid ethernet/IP/TCP frame. It generates a packet in a shape of TCP, UDP, ICMP, ARP, IP, Raw ethernet, with or without a VLAN tag. If dl_type is other than IP or ARP, the upper layer parameters will be ignored If nw_proto is other than TCP, UDP or ICMP, the upper layer parameters will be ignored Supports a few parameters @param pktlen Length of packet in bytes w/o CRC @param dl_dst Destination MAC @param dl_src Source MAC @param dl_vlan VLAN ID, No VLAN tags if the value is 0xffff @param dl_vlan_pcp VLAN priority. Valid only dl_vlan is in a valid range @param dl_vlan_cfi VLAN CFI @param dl_type Type of L3 @param nw_src IP source @param nw_dst IP destination @param nw_tos IP ToS @param nw_proto L4 protocol When ARP is specified in dl_type, it is used for op code @param tp_dst UDP/TCP destination port @param tp_src UDP/TCP source port @return valid packet """ # Note Dot1Q.id is really CFI if (dl_vlan == 0xffff): pkt = scapy.Ether(dst=dl_dst, src=dl_src) else: dl_vlan = dl_vlan & 0x0fff pkt = scapy.Ether(dst=dl_dst, src=dl_src)/ \ scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan) if (dl_type == ETHERTYPE_IP): pkt = pkt / scapy.IP(src=nw_src, dst=nw_dst, tos=nw_tos) if (nw_proto == socket.IPPROTO_TCP): pkt = pkt / scapy.TCP(sport=tp_src, dport=tp_dst) elif (nw_proto == socket.IPPROTO_UDP): pkt = pkt / scapy.UDP(sport=tp_src, dport=tp_dst) elif (nw_proto == socket.IPPROTO_ICMP): pkt = pkt / scapy.ICMP(type=tp_src, code=tp_dst) elif (dl_type == ETHERTYPE_ARP): pkt = pkt / scapy.ARP( op=nw_proto, hwsrc=dl_src, psrc=nw_src, hwdst=dl_dst, pdst=nw_dst) return pkt pkt = pkt / ("D" * (pktlen - len(pkt))) return pkt
def generate_and_verify_balancing_traffic(duthost, ptfhost, ptfadapter, src_port, dst_port, ip_src, ip_dst, pktlen, ttl): """ Send TCP packets and verify balancing range between sub-ports. Args: duthost: DUT host object ptfhost: PTF host object ptfadapter: PTF adapter src_port: Port of PTF dst_port: Port of DUT ip_src: Source IP address of PTF ip_dst: Destination IP address of DUT pkt_action: Packet action (forwarded or drop) pktlen: packet length ttl: Time to live """ router_mac = duthost.facts['router_mac'] src_port_number = int(get_port_number(src_port)) src_mac = ptfadapter.dataplane.get_mac(0, src_port_number) ip_src = '10.0.0.1' ip_dst = ip_dst.split('/')[0] vlan_vid = None dl_vlan_enable = False send_pkt_length = pktlen if constants.VLAN_SUB_INTERFACE_SEPARATOR in src_port: vlan_vid = int( src_port.split(constants.VLAN_SUB_INTERFACE_SEPARATOR)[1]) dl_vlan_enable = True send_pkt_length += len(scapyall.Dot1Q()) pkt = create_packet(eth_src=src_mac, eth_dst=router_mac, ip_src=ip_src, ip_dst=ip_dst, vlan_vid=vlan_vid, dl_vlan_enable=dl_vlan_enable, tr_type='TCP', ttl=64, pktlen=send_pkt_length) ptfadapter.dataplane.flush() time.sleep(2) for _ in range(BALANCING_TEST_TIMES * len(dst_port)): testutils.send_packet(ptfadapter, src_port_number, pkt) pkt['IP'].src = str( ipaddress.ip_address(pkt['IP'].src.encode().decode()) + 1) exp_pkt = create_packet(eth_src=router_mac, eth_dst=src_mac, ip_src=ip_src, ip_dst=ip_dst, vlan_vid=None, dl_vlan_enable=False, tr_type='TCP', ttl=ttl, pktlen=pktlen) ifaces_map = ptfhost.host.options['variable_manager'].extra_vars[ 'ifaces_map'] config_port_indices = {v: k for k, v in ifaces_map.items()} dst_port_numbers = [ config_port_indices[k] for k in config_port_indices if k in dst_port ] ignore_fields = [("Ether", "dst"), ("IP", "src"), ("IP", "chksum"), ("TCP", "chksum")] if dl_vlan_enable: ignore_fields.append(("Ether", "type")) pkt_filter = FilterPktBuffer(ptfadapter=ptfadapter, exp_pkt=exp_pkt, dst_port_numbers=dst_port_numbers, match_fields=[("Ethernet", "src"), ("IP", "dst"), ('TCP', "dport")], ignore_fields=ignore_fields) pkt_in_buffer = pkt_filter.filter_pkt_in_buffer() pytest_assert(pkt_in_buffer is True, "Expected packet not available:\n{}".format(pkt_in_buffer)) pytest_assert(check_balancing(pkt_filter.matched_index), "Balancing error:\n{}".format(pkt_filter.matched_index))
sai_remove_acl_table_group $acl_table_group back vlan sai_remove_vlan_member $memtap0 sai_remove_vlan_member $memtap1 sai_remove_vlan $vlan75 back bridge sai_remove_bridge_port $brgportlag back lag sai_remove_lag_member $mem30 sai_remove_lag $lag0 back home ''' packet_info = scapy_t.Ether( src="00:00:11:00:11:00", dst="00:00:11:00:11:23") / scapy_t.Dot1Q(vlan=75) / scapy_t.IP( src="100.1.1.1", dst="100.1.1.2") / scapy_t.TCP(sport=2567, dport=2569) # #expectedData: This dictionary expected egress stream for each egress port. # expectedData = { 'expect1': '', }
def ConfigureHeaderTemplate(self, rdma_session, initiator, responder, flow, isipv6, forward, ah_handle): logger.info("rdma_session: %s" % rdma_session.GID()) logger.info("session: %s" % rdma_session.session.GID()) logger.info("flow_ep1: %s ep1: %s" \ %(initiator.GID(), initiator.ep.GID())) logger.info("flow_ep2: %s ep2: %s" \ %(responder.GID(), responder.ep.GID())) logger.info("src_ip: %s" % initiator.addr.get()) logger.info("dst_ip: %s" % responder.addr.get()) logger.info("src_mac: %s" % initiator.ep.macaddr.get()) logger.info("dst_mac: %s" % responder.ep.macaddr.get()) logger.info("proto: %s" % flow.proto) logger.info("sport: %s" % flow.sport) logger.info("dport: %s" % flow.dport) logger.info("ah_handle: %d" % ah_handle) if forward: logger.info("src_qp: %d pd: %s" % (rdma_session.lqp.id, rdma_session.lqp.pd.GID())) logger.info("dst_qp: %d pd: %s" % (rdma_session.rqp.id, rdma_session.rqp.pd.GID())) else: logger.info("src_qp: %d pd: %s" % (rdma_session.rqp.id, rdma_session.rqp.pd.GID())) logger.info("dst_qp: %d pd: %s" % (rdma_session.lqp.id, rdma_session.lqp.pd.GID())) logger.info("isipv6: %d" % (isipv6)) logger.info("isVXLAN: %d" % (rdma_session.IsVXLAN)) EthHdr = scapy.Ether(src=initiator.ep.macaddr.get(), dst=responder.ep.macaddr.get()) Dot1qHdr = scapy.Dot1Q(vlan=initiator.ep.intf.encap_vlan_id, prio=flow.txqos.cos) if isipv6: IpHdr = scapy.IPv6(src=initiator.addr.get(), dst=responder.addr.get(), tc=flow.txqos.dscp, plen=0) else: IpHdr = scapy.IP( src=initiator.addr.get(), dst=responder.addr.get(), tos=0, # keep tos = 0 to not trigger ecn mark len=0, chksum=0) if forward: UdpHdr = scapy.UDP(sport=flow.sport, dport=flow.dport, len=0, chksum=0) else: UdpHdr = scapy.UDP(sport=flow.dport, dport=flow.sport, len=0, chksum=0) self.HdrTemplate = EthHdr / Dot1qHdr / IpHdr / UdpHdr self.ah_handle = ah_handle # header_template size is 66. The address is maintained only to calculate # dcqcn_cb address. # 200 = [ 66 (header_template_t) + 1 (ah_size) + 64 (dcqcncb_t) + 64 (rome_receiver_cb_t)] 8 byte aligned self.header_temp_addr = self.lif.rdma_at_base_addr + (ah_handle * 200) self.modify_qp_oper |= 1 << rdma_pb2.RDMA_UPDATE_QP_OPER_SET_AV logger.info(" RdmaQpUpdate Oper: SET_AV ah_handle: %d " % (self.ah_handle)) if (GlobalOptions.dryrun): return resmgr.HostMemoryAllocator.write(self.hdr_slab.mem_handle, bytes(self.HdrTemplate)) #adminapi.ModifyQps(self.lif, [self]) #self.modify_qp_oper = 0 return
def traffic_sender(linkid, vlanid): payload = s.Ether() / s.Dot1Q(vlan=int(vlanid)) / s.IP() / s.ICMP() s.sendp(payload, iface=linkid, count=number_of_packets)
def simple_udp_packet(pktlen=100, dl_dst='48:d2:24:0f:60:52', dl_src='00:1b:21:02:d1:57', dl_vlan_enable=False, dl_vlan=0, dl_vlan_pcp=0, dl_vlan_cfi=0, ip_src='1.1.1.5', ip_dst='1.1.1.125', ip_tos=0, udp_sport=4567, udp_dport=9, ip_ihl=None, ip_options=False ): """ Return a simple dataplane UDP packet Supports a few parameters: @param len Length of packet in bytes w/o CRC @param dl_dst Destinatino MAC @param dl_src Source MAC @param dl_vlan_enable True if the packet is with vlan, False otherwise @param dl_vlan VLAN ID @param dl_vlan_pcp VLAN priority @param ip_src IP source @param ip_dst IP destination @param ip_tos IP ToS @param udp_dport UDP destination port @param udp_sport UDP source port Generates a simple UDP packet. Users shouldn't assume anything about this packet other than that it is a valid ethernet/IP/UDP frame. """ if 0 > pktlen: pktlen = MINSIZE # create udp header udp = scapy.UDP(sport=udp_sport, dport=udp_dport) # create ip header if not ip_options: ip = scapy.IP(src=ip_src, dst= ip_dst, tos=ip_tos, ihl=ip_ihl) else: ip = scapy.IP(src=ip_src, dst=ip_dst, tos=ip_tos, ihl=ip_ihl, options=ip_options) # create ethernet header ether = scapy.Ether(dst=dl_dst, src=dl_src) # add the vlan header if if is enabled and create the pkt. if dl_vlan_enable : dot1q = scapy.Dot1Q(prio=dl_vlan_pcp, id=dl_vlan_cfi, vlan=dl_vlan) pkt = ether/ dot1q / ip / udp else: pkt = ether/ ip / udp pkt = pkt/("D" * (pktlen - len(pkt))) #print pkt.show() return pkt
import scapy.all as scapy __author__ = 'J.Carlos Romero' __license__ = 'GPLv3' interface = scapy.get_if_list()[-1] src_mac = '60:50:40:30:20:10' # broadcast MAC dst_mac = 'ff:ff:ff:ff:ff:ff' src_ip = '1.1.1.1' dst_ip = '255.255.255.255' native_vlan = 1 hop_vlan = 2 payload = scapy.ICMP() packet = (scapy.Ether(src=src_mac, dst=dst_mac) / scapy.Dot1Q(vlan=native_vlan) / scapy.Dot1Q(vlan=hop_vlan) / scapy.IP(src=src_ip, dst=dst_ip)) scapy.sendp(packet / payload, iface=interface) packet.show() packet.pdfdump(layer_shift=1)