1 # Copyright (c) 2019 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """PacketVerifier module.
18 | >>> from scapy.all import *
19 | >>> from PacketVerifier import *
20 | >>> rxq = RxQueue('eth1')
21 | >>> txq = TxQueue('eth1')
22 | >>> src_mac = "AA:BB:CC:DD:EE:FF"
23 | >>> dst_mac = "52:54:00:ca:5d:0b"
24 | >>> src_ip = "11.11.11.10"
25 | >>> dst_ip = "11.11.11.11"
26 | >>> sent_packets = []
27 | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
28 | ... IP(src=src_ip, dst=dst_ip) /
30 | >>> sent_packets.append(pkt_send)
31 | >>> txq.send(pkt_send)
32 | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
33 | ... ARP(hwsrc=src_mac, psrc=src_ip, hwdst=dst_mac, pdst=dst_ip, op=2)
34 | >>> sent_packets.append(pkt_send)
35 | >>> txq.send(pkt_send)
36 | >>> rxq.recv(100, sent_packets).show()
38 | dst = aa:bb:cc:dd:ee:ff
39 | src = 52:54:00:ca:5d:0b
62 | load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'
70 from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
71 from scapy.config import conf
72 from scapy.layers.inet6 import IPv6
73 from scapy.layers.l2 import Ether, ARP
74 from scapy.packet import Raw
76 # Enable libpcap's L2listen
78 import scapy.arch.pcapdnet # pylint: disable=C0413, unused-import
81 u"RxQueue", u"TxQueue", u"Interface", u"create_gratuitous_arp_request",
82 u"auto_pad", u"checksum_equal"
85 # TODO: http://stackoverflow.com/questions/320232/
86 # ensuring-subprocesses-are-dead-on-exiting-python-program
90 """Base class for TX and RX queue objects for packet verifier."""
91 def __init__(self, interface_name):
93 f"sudo echo 1 > /proc/sys/net/ipv6/conf/{interface_name}/"
96 os.system(f"sudo ip link set {interface_name} up promisc on")
97 self._ifname = interface_name
100 def extract_one_packet(buf):
101 """Extract one packet from the incoming buf buffer.
103 Takes string as input and looks for first whole packet in it.
104 If it finds one, it returns substring from the buf parameter.
106 :param buf: String representation of incoming packet buffer.
108 :returns: String representation of first packet in buf.
117 ether_type = Ether(buf[0:14]).type
118 except AttributeError:
119 raise RuntimeError(f"No EtherType in packet {buf!r}")
121 if ether_type == ETH_P_IP:
122 # 14 is Ethernet fame header size.
123 # 4 bytes is just enough to look for length in ip header.
124 # ip total length contains just the IP packet length so add the Ether
126 pkt_len = Ether(buf[0:14+4]).len + 14
129 elif ether_type == ETH_P_IPV6:
130 if not Ether(buf[0:14+6]).haslayer(IPv6):
131 raise RuntimeError(f"Invalid IPv6 packet {buf!r}")
132 # ... to add to the above, 40 bytes is the length of IPV6 header.
133 # The ipv6.len only contains length of the payload and not the header
134 pkt_len = Ether(buf)[u"IPv6"].plen + 14 + 40
137 elif ether_type == ETH_P_ARP:
138 pkt = Ether(buf[:20])
139 if not pkt.haslayer(ARP):
140 raise RuntimeError(u"Incomplete ARP packet")
141 # len(eth) + arp(2 hw addr type + 2 proto addr type
142 # + 1b len + 1b len + 2b operation)
145 pkt_len += 2 * pkt.getlayer(ARP).hwlen
146 pkt_len += 2 * pkt.getlayer(ARP).plen
149 elif ether_type == 32821: # RARP (Reverse ARP)
150 pkt = Ether(buf[:20])
151 pkt.type = ETH_P_ARP # Change to ARP so it works with scapy
153 if not pkt.haslayer(ARP):
155 raise RuntimeError(u"Incomplete RARP packet")
157 # len(eth) + arp(2 hw addr type + 2 proto addr type
158 # + 1b len + 1b len + 2b operation)
160 pkt_len += 2 * pkt.getlayer(ARP).hwlen
161 pkt_len += 2 * pkt.getlayer(ARP).plen
165 raise RuntimeError(f"Unknown protocol {ether_type}")
170 if len(buf) < pkt_len:
173 return buf[0:pkt_len]
176 def packet_reader(interface_name, queue):
177 """Sub-process routine that reads packets and puts them to queue.
179 This function is meant to be run in separate subprocess and is in tight
180 loop reading raw packets from interface passed as parameter.
182 :param interface_name: Name of interface to read packets from.
183 :param queue: Queue in which this function will push incoming packets.
184 :type interface_name: str
185 :type queue: multiprocessing.Queue
187 sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
190 pkt = sock.recv(0x7fff)
194 class RxQueue(PacketVerifier):
195 """Receive queue object.
197 This object creates raw socket, reads packets from it and provides
198 function to access them.
200 :param interface_name: Which interface to bind to.
201 :type interface_name: str
203 def __init__(self, interface_name):
204 PacketVerifier.__init__(self, interface_name)
205 self._sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
207 def recv(self, timeout=3, ignore=None, verbose=True):
208 """Read next received packet.
210 Returns scapy's Ether() object created from next packet in the queue.
211 Queue is being filled in parallel in subprocess. If no packet
212 arrives in given timeout queue.Empty exception will be risen.
214 :param timeout: How many seconds to wait for next packet.
215 :param ignore: List of packets that should be ignored.
216 :param verbose: Used to suppress detailed logging of received packets.
221 :returns: Ether() initialized object from packet data.
225 if ignore is not None:
226 for ig_pkt in ignore:
227 # Auto pad all packets in ignore list
228 ignore_list.append(str(auto_pad(ig_pkt)))
230 rlist, _, _ = select.select([self._sock], [], [], timeout)
231 if self._sock not in rlist:
234 pkt = self._sock.recv(0x7fff)
235 pkt_pad = str(auto_pad(pkt))
236 print(f"Received packet on {self._ifname} of len {len(pkt)}")
238 pkt.show2() # pylint: disable=no-member
240 if pkt_pad in ignore_list:
241 ignore_list.remove(pkt_pad)
242 print(u"Received packet ignored.")
247 class TxQueue(PacketVerifier):
248 """Transmission queue object.
250 This object is used to send packets over RAW socket on a interface.
252 :param interface_name: Which interface to send packets from.
253 :type interface_name: str
255 def __init__(self, interface_name):
256 PacketVerifier.__init__(self, interface_name)
257 self._sock = conf.L2socket(iface=interface_name, type=ETH_P_ALL)
259 def send(self, pkt, verbose=True):
260 """Send packet out of the bound interface.
262 :param pkt: Packet to send.
263 :param verbose: Used to suppress detailed logging of sent packets.
264 :type pkt: string or scapy Packet derivative.
268 print(f"Sending packet out of {self._ifname} of len {len(pkt)}")
277 """Class for network interfaces. Contains methods for sending and receiving
279 def __init__(self, if_name):
280 """Initialize the interface class.
282 :param if_name: Name of the interface.
285 self.if_name = if_name
286 self.sent_packets = []
287 self.rxq = RxQueue(if_name)
288 self.txq = TxQueue(if_name)
290 def send_pkt(self, pkt):
291 """Send the provided packet out the interface."""
292 self.sent_packets.append(pkt)
295 def recv_pkt(self, timeout=3):
296 """Read one packet from the interface's receive queue.
298 :param timeout: Timeout value in seconds.
300 :returns: Ether() initialized object from packet data.
303 return self.rxq.recv(timeout, self.sent_packets)
306 def create_gratuitous_arp_request(src_mac, src_ip):
307 """Creates scapy representation of gratuitous ARP request."""
308 return (Ether(src=src_mac, dst=u"ff:ff:ff:ff:ff:ff") /
309 ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip)
313 def auto_pad(packet):
314 """Pads zeroes at the end of the packet if the total len < 60 bytes."""
315 # padded = str(packet)
317 packet[Raw].load += (b"\0" * (60 - len(packet)))
321 def checksum_equal(chksum1, chksum2):
322 """Compares two checksums in one's complement notation.
324 Checksums to be compared are calculated as 16 bit one's complement of the
325 one's complement sum of 16 bit words of some buffer.
326 In one's complement notation 0x0000 (positive zero) and 0xFFFF
327 (negative zero) are equivalent.
329 :param chksum1: First checksum.
330 :param chksum2: Second checksum.
331 :type chksum1: uint16
332 :type chksum2: uint16
334 :returns: True if checksums are equivalent, False otherwise.
337 if chksum1 == 0xFFFF:
339 if chksum2 == 0xFFFF:
341 return chksum1 == chksum2