1 # Copyright (c) 2016 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"
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.all import Ether, ARP, Packet
72 from scapy.layers.inet6 import IPv6
74 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',
75 'auto_pad', 'checksum_equal']
77 # TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program
80 class PacketVerifier(object):
81 """Base class for TX and RX queue objects for packet verifier."""
82 def __init__(self, interface_name):
83 os.system('sudo echo 1 > /proc/sys/net/ipv6/conf/{0}/disable_ipv6'
84 .format(interface_name))
85 os.system('sudo ip link set {0} up promisc on'.format(interface_name))
86 self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
88 self._sock.bind((interface_name, ETH_P_ALL))
89 self._ifname = interface_name
92 def extract_one_packet(buf):
93 """Extract one packet from the incoming buf buffer.
95 Takes string as input and looks for first whole packet in it.
96 If it finds one, it returns substring from the buf parameter.
98 :param buf: String representation of incoming packet buffer.
100 :return: String representation of first packet in buf.
109 # print buf.__repr__()
110 # print Ether(buf).__repr__()
111 # print len(Ether(buf))
114 ether_type = Ether(buf[0:14]).type
115 except AttributeError:
117 'No EtherType in packet {0}'.format(buf.__repr__()))
119 if ether_type == ETH_P_IP:
120 # 14 is Ethernet fame header size.
121 # 4 bytes is just enough to look for length in ip header.
122 # ip total length contains just the IP packet length so add the Ether
124 pkt_len = Ether(buf[0:14+4]).len + 14
127 elif ether_type == ETH_P_IPV6:
128 if not Ether(buf[0:14+6]).haslayer(IPv6):
130 'Invalid IPv6 packet {0}'.format(buf.__repr__()))
131 # ... to add to the above, 40 bytes is the length of IPV6 header.
132 # The ipv6.len only contains length of the payload and not the header
133 pkt_len = Ether(buf)['IPv6'].plen + 14 + 40
136 elif ether_type == ETH_P_ARP:
137 pkt = Ether(buf[:20])
138 if not pkt.haslayer(ARP):
139 raise RuntimeError('Incomplete ARP packet')
140 # len(eth) + arp(2 hw addr type + 2 proto addr type
141 # + 1b len + 1b len + 2b operation)
144 pkt_len += 2 * pkt.getlayer(ARP).hwlen
145 pkt_len += 2 * pkt.getlayer(ARP).plen
148 elif ether_type == 32821: # RARP (Reverse ARP)
149 pkt = Ether(buf[:20])
150 pkt.type = ETH_P_ARP # Change to ARP so it works with scapy
151 pkt = Ether(str(pkt))
152 if not pkt.haslayer(ARP):
154 raise RuntimeError('Incomplete RARP packet')
156 # len(eth) + arp(2 hw addr type + 2 proto addr type
157 # + 1b len + 1b len + 2b operation)
159 pkt_len += 2 * pkt.getlayer(ARP).hwlen
160 pkt_len += 2 * pkt.getlayer(ARP).plen
164 raise RuntimeError('Unknown protocol {0}'.format(ether_type))
169 if len(buf) < pkt_len:
172 return buf[0:pkt_len]
175 def packet_reader(interface_name, queue):
176 """Sub-process routine that reads packets and puts them to queue.
178 This function is meant to be run in separate subprocess and is in tight
179 loop reading raw packets from interface passed as parameter.
181 :param interface_name: Name of interface to read packets from.
182 :param queue: Queue in which this function will push incoming packets.
183 :type interface_name: str
184 :type queue: multiprocessing.Queue
187 sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
188 sock.bind((interface_name, ETH_P_ALL))
191 pkt = sock.recv(0x7fff)
195 class RxQueue(PacketVerifier):
196 """Receive queue object.
198 This object creates raw socket, reads packets from it and provides
199 function to access them.
201 :param interface_name: Which interface to bind to.
202 :type interface_name: str
204 def __init__(self, interface_name):
205 PacketVerifier.__init__(self, interface_name)
207 def recv(self, timeout=3, ignore=None):
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: Packet list that should be ignored.
219 :return: Ether() initialized object from packet data.
222 (rlist, _, _) = select.select([self._sock], [], [], timeout)
223 if self._sock not in rlist:
226 pkt = self._sock.recv(0x7fff)
227 pkt_pad = auto_pad(pkt)
228 print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
232 if ignore is not None:
233 for i, ig_pkt in enumerate(ignore):
234 # Auto pad all packets in ignore list
235 ignore[i] = auto_pad(ig_pkt)
236 for ig_pkt in ignore:
237 if ig_pkt == pkt_pad:
238 # Found the packet in ignore list, get another one
239 # TODO: subtract timeout - time_spent in here
240 ignore.remove(ig_pkt)
241 return self.recv(timeout, ignore)
246 class TxQueue(PacketVerifier):
247 """Transmission queue object.
249 This object is used to send packets over RAW socket on a interface.
251 :param interface_name: Which interface to send packets from.
252 :type interface_name: str
254 def __init__(self, interface_name):
255 PacketVerifier.__init__(self, interface_name)
258 """Send packet out of the bound interface.
260 :param pkt: Packet to send.
261 :type pkt: string or scapy Packet derivative.
263 print 'Sending packet out of {0} of len {1}'.format(self._ifname,
265 Ether(str(pkt)).show2()
268 pkt = auto_pad(str(pkt))
272 class Interface(object):
273 def __init__(self, if_name):
274 self.if_name = if_name
275 self.sent_packets = []
276 self.rxq = RxQueue(if_name)
277 self.txq = TxQueue(if_name)
279 def send_pkt(self, pkt):
280 self.sent_packets.append(pkt)
283 def recv_pkt(self, timeout=3):
284 return self.rxq.recv(timeout, self.sent_packets)
287 def create_gratuitous_arp_request(src_mac, src_ip):
288 """Creates scapy representation of gratuitous ARP request."""
289 return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
290 ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
293 def auto_pad(packet):
294 """Pads zeroes at the end of the packet if the total len < 60 bytes."""
297 padded += ('\0' * (60 - len(padded)))
301 def checksum_equal(chksum1, chksum2):
302 """Compares two checksums in one's complement notation.
304 Checksums to be compared are calculated as 16 bit one's complement of the
305 one's complement sum of 16 bit words of some buffer.
306 In one's complement notation 0x0000 (positive zero) and 0xFFFF
307 (negative zero) are equivalent.
309 :param chksum1: First checksum.
310 :param chksum2: Second checksum.
311 :type chksum1: uint16
312 :type chksum2: uint16
314 :return: True if checksums are equivalent, False otherwise.
317 if chksum1 == 0xFFFF:
319 if chksum2 == 0xFFFF:
321 return chksum1 == chksum2