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
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/
78 # ensuring-subprocesses-are-dead-on-exiting-python-program
81 class PacketVerifier(object):
82 """Base class for TX and RX queue objects for packet verifier."""
83 def __init__(self, interface_name):
84 os.system('sudo echo 1 > /proc/sys/net/ipv6/conf/{0}/disable_ipv6'
85 .format(interface_name))
86 os.system('sudo ip link set {0} up promisc on'.format(interface_name))
87 self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
89 self._sock.bind((interface_name, ETH_P_ALL))
90 self._ifname = interface_name
93 def extract_one_packet(buf):
94 """Extract one packet from the incoming buf buffer.
96 Takes string as input and looks for first whole packet in it.
97 If it finds one, it returns substring from the buf parameter.
99 :param buf: String representation of incoming packet buffer.
101 :returns: String representation of first packet in buf.
110 ether_type = Ether(buf[0:14]).type
111 except AttributeError:
113 'No EtherType in packet {0}'.format(buf.__repr__()))
115 if ether_type == ETH_P_IP:
116 # 14 is Ethernet fame header size.
117 # 4 bytes is just enough to look for length in ip header.
118 # ip total length contains just the IP packet length so add the Ether
120 pkt_len = Ether(buf[0:14+4]).len + 14
123 elif ether_type == ETH_P_IPV6:
124 if not Ether(buf[0:14+6]).haslayer(IPv6):
126 'Invalid IPv6 packet {0}'.format(buf.__repr__()))
127 # ... to add to the above, 40 bytes is the length of IPV6 header.
128 # The ipv6.len only contains length of the payload and not the header
129 pkt_len = Ether(buf)['IPv6'].plen + 14 + 40
132 elif ether_type == ETH_P_ARP:
133 pkt = Ether(buf[:20])
134 if not pkt.haslayer(ARP):
135 raise RuntimeError('Incomplete ARP packet')
136 # len(eth) + arp(2 hw addr type + 2 proto addr type
137 # + 1b len + 1b len + 2b operation)
140 pkt_len += 2 * pkt.getlayer(ARP).hwlen
141 pkt_len += 2 * pkt.getlayer(ARP).plen
144 elif ether_type == 32821: # RARP (Reverse ARP)
145 pkt = Ether(buf[:20])
146 pkt.type = ETH_P_ARP # Change to ARP so it works with scapy
147 pkt = Ether(str(pkt))
148 if not pkt.haslayer(ARP):
150 raise RuntimeError('Incomplete RARP packet')
152 # len(eth) + arp(2 hw addr type + 2 proto addr type
153 # + 1b len + 1b len + 2b operation)
155 pkt_len += 2 * pkt.getlayer(ARP).hwlen
156 pkt_len += 2 * pkt.getlayer(ARP).plen
160 raise RuntimeError('Unknown protocol {0}'.format(ether_type))
165 if len(buf) < pkt_len:
168 return buf[0:pkt_len]
171 def packet_reader(interface_name, queue):
172 """Sub-process routine that reads packets and puts them to queue.
174 This function is meant to be run in separate subprocess and is in tight
175 loop reading raw packets from interface passed as parameter.
177 :param interface_name: Name of interface to read packets from.
178 :param queue: Queue in which this function will push incoming packets.
179 :type interface_name: str
180 :type queue: multiprocessing.Queue
183 sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
184 sock.bind((interface_name, ETH_P_ALL))
187 pkt = sock.recv(0x7fff)
191 class RxQueue(PacketVerifier):
192 """Receive queue object.
194 This object creates raw socket, reads packets from it and provides
195 function to access them.
197 :param interface_name: Which interface to bind to.
198 :type interface_name: str
200 def __init__(self, interface_name):
201 PacketVerifier.__init__(self, interface_name)
203 def recv(self, timeout=3, ignore=None, verbose=True):
204 """Read next received packet.
206 Returns scapy's Ether() object created from next packet in the queue.
207 Queue is being filled in parallel in subprocess. If no packet
208 arrives in given timeout queue.Empty exception will be risen.
210 :param timeout: How many seconds to wait for next packet.
211 :param ignore: List of packets that should be ignored.
212 :param verbose: Used to suppress detailed logging of received packets.
217 :returns: Ether() initialized object from packet data.
220 (rlist, _, _) = select.select([self._sock], [], [], timeout)
221 if self._sock not in rlist:
224 pkt = self._sock.recv(0x7fff)
225 pkt_pad = auto_pad(pkt)
226 print'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
231 if ignore is not None:
232 for i, ig_pkt in enumerate(ignore):
233 # Auto pad all packets in ignore list
234 ignore[i] = auto_pad(ig_pkt)
235 for ig_pkt in ignore:
236 if ig_pkt == pkt_pad:
237 # Found the packet in ignore list, get another one
238 # TODO: subtract timeout - time_spent in here
239 ignore.remove(ig_pkt)
240 return self.recv(timeout, ignore, verbose)
245 class TxQueue(PacketVerifier):
246 """Transmission queue object.
248 This object is used to send packets over RAW socket on a interface.
250 :param interface_name: Which interface to send packets from.
251 :type interface_name: str
253 def __init__(self, interface_name):
254 PacketVerifier.__init__(self, interface_name)
256 def send(self, pkt, verbose=True):
257 """Send packet out of the bound interface.
259 :param pkt: Packet to send.
260 :param verbose: Used to supress detailed logging of sent packets.
261 :type pkt: string or scapy Packet derivative.
264 print 'Sending packet out of {0} of len {1}'.format(self._ifname,
267 Ether(str(pkt)).show2()
270 pkt = auto_pad(str(pkt))
274 class Interface(object):
275 """Class for network interfaces. Contains methods for sending and receiving
277 def __init__(self, if_name):
278 """Initialize the interface class.
280 :param if_name: Name of the interface.
283 self.if_name = if_name
284 self.sent_packets = []
285 self.rxq = RxQueue(if_name)
286 self.txq = TxQueue(if_name)
288 def send_pkt(self, pkt):
289 """Send the provided packet out the interface."""
290 self.sent_packets.append(pkt)
293 def recv_pkt(self, timeout=3):
294 """Read one packet from the interface's receive queue.
296 :param timeout: Timeout value in seconds.
298 :returns: Ether() initialized object from packet data.
301 return self.rxq.recv(timeout, self.sent_packets)
304 def create_gratuitous_arp_request(src_mac, src_ip):
305 """Creates scapy representation of gratuitous ARP request."""
306 return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
307 ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
310 def auto_pad(packet):
311 """Pads zeroes at the end of the packet if the total len < 60 bytes."""
314 padded += ('\0' * (60 - len(padded)))
318 def checksum_equal(chksum1, chksum2):
319 """Compares two checksums in one's complement notation.
321 Checksums to be compared are calculated as 16 bit one's complement of the
322 one's complement sum of 16 bit words of some buffer.
323 In one's complement notation 0x0000 (positive zero) and 0xFFFF
324 (negative zero) are equivalent.
326 :param chksum1: First checksum.
327 :param chksum2: Second checksum.
328 :type chksum1: uint16
329 :type chksum2: uint16
331 :returns: True if checksums are equivalent, False otherwise.
334 if chksum1 == 0xFFFF:
336 if chksum2 == 0xFFFF:
338 return chksum1 == chksum2