Fix warnings reported by gen_doc.sh
[csit.git] / resources / libraries / python / PacketVerifier.py
1 # Copyright (c) 2018 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:
5 #
6 #     http://www.apache.org/licenses/LICENSE-2.0
7 #
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.
13
14 """PacketVerifier module.
15
16   Example. ::
17
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) /
29     | ... ICMP()
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()
37     | ###[ Ethernet ]###
38     |   dst       = aa:bb:cc:dd:ee:ff
39     |   src       = 52:54:00:ca:5d:0b
40     |   type      = 0x800
41     | ###[ IP ]###
42     |   version   = 4L
43     |   ihl       = 5L
44     |   tos       = 0x0
45     |   len       = 28
46     |   id        = 43183
47     |   flags     =
48     |   frag      = 0L
49     |   ttl       = 64
50     |   proto     = icmp
51     |   chksum    = 0xa607
52     |   src       = 11.11.11.11
53     |   dst       = 11.11.11.10
54     |   options
55     | ###[ ICMP ]###
56     |   type      = echo-reply
57     |   code      = 0
58     |   chksum    = 0xffff
59     |   id        = 0x0
60     |   seq       = 0x0
61     | ###[ Padding ]###
62     |   load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'
63
64   Example end.
65 """
66
67 import os
68 import select
69
70 from scapy.config import conf
71 from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
72 from scapy.layers.inet6 import IPv6
73 from scapy.layers.l2 import Ether, ARP
74
75 # Enable libpcap's L2listen
76 conf.use_pcap = True
77 import scapy.arch.pcapdnet  # pylint: disable=C0413, unused-import
78
79 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',
80            'auto_pad', 'checksum_equal']
81
82 # TODO: http://stackoverflow.com/questions/320232/
83 # ensuring-subprocesses-are-dead-on-exiting-python-program
84
85
86 class PacketVerifier(object):
87     """Base class for TX and RX queue objects for packet verifier."""
88     def __init__(self, interface_name):
89         os.system('sudo echo 1 > /proc/sys/net/ipv6/conf/{0}/disable_ipv6'
90                   .format(interface_name))
91         os.system('sudo ip link set {0} up promisc on'.format(interface_name))
92         self._ifname = interface_name
93
94
95 def extract_one_packet(buf):
96     """Extract one packet from the incoming buf buffer.
97
98     Takes string as input and looks for first whole packet in it.
99     If it finds one, it returns substring from the buf parameter.
100
101     :param buf: String representation of incoming packet buffer.
102     :type buf: str
103     :returns: String representation of first packet in buf.
104     :rtype: str
105     """
106     pkt_len = 0
107
108     if len(buf) < 60:
109         return None
110
111     try:
112         ether_type = Ether(buf[0:14]).type
113     except AttributeError:
114         raise RuntimeError(
115             'No EtherType in packet {0}'.format(buf.__repr__()))
116
117     if ether_type == ETH_P_IP:
118         # 14 is Ethernet fame header size.
119         # 4 bytes is just enough to look for length in ip header.
120         # ip total length contains just the IP packet length so add the Ether
121         #     header.
122         pkt_len = Ether(buf[0:14+4]).len + 14
123         if len(buf) < 60:
124             return None
125     elif ether_type == ETH_P_IPV6:
126         if not Ether(buf[0:14+6]).haslayer(IPv6):
127             raise RuntimeError(
128                 'Invalid IPv6 packet {0}'.format(buf.__repr__()))
129         # ... to add to the above, 40 bytes is the length of IPV6 header.
130         #   The ipv6.len only contains length of the payload and not the header
131         pkt_len = Ether(buf)['IPv6'].plen + 14 + 40
132         if len(buf) < 60:
133             return None
134     elif ether_type == ETH_P_ARP:
135         pkt = Ether(buf[:20])
136         if not pkt.haslayer(ARP):
137             raise RuntimeError('Incomplete ARP packet')
138         # len(eth) + arp(2 hw addr type + 2 proto addr type
139         #                + 1b len + 1b len + 2b operation)
140
141         pkt_len = 14 + 8
142         pkt_len += 2 * pkt.getlayer(ARP).hwlen
143         pkt_len += 2 * pkt.getlayer(ARP).plen
144
145         del pkt
146     elif ether_type == 32821:  # RARP (Reverse ARP)
147         pkt = Ether(buf[:20])
148         pkt.type = ETH_P_ARP  # Change to ARP so it works with scapy
149         pkt = Ether(str(pkt))
150         if not pkt.haslayer(ARP):
151             pkt.show()
152             raise RuntimeError('Incomplete RARP packet')
153
154         # len(eth) + arp(2 hw addr type + 2 proto addr type
155         #                + 1b len + 1b len + 2b operation)
156         pkt_len = 14 + 8
157         pkt_len += 2 * pkt.getlayer(ARP).hwlen
158         pkt_len += 2 * pkt.getlayer(ARP).plen
159
160         del pkt
161     else:
162         raise RuntimeError('Unknown protocol {0}'.format(ether_type))
163
164     if pkt_len < 60:
165         pkt_len = 60
166
167     if len(buf) < pkt_len:
168         return None
169
170     return buf[0:pkt_len]
171
172
173 def packet_reader(interface_name, queue):
174     """Sub-process routine that reads packets and puts them to queue.
175
176     This function is meant to be run in separate subprocess and is in tight
177     loop reading raw packets from interface passed as parameter.
178
179     :param interface_name: Name of interface to read packets from.
180     :param queue: Queue in which this function will push incoming packets.
181     :type interface_name: str
182     :type queue: multiprocessing.Queue
183     :returns: None
184     """
185     sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
186
187     while True:
188         pkt = sock.recv(0x7fff)
189         queue.put(pkt)
190
191
192 class RxQueue(PacketVerifier):
193     """Receive queue object.
194
195     This object creates raw socket, reads packets from it and provides
196     function to access them.
197
198     :param interface_name: Which interface to bind to.
199     :type interface_name: str
200     """
201     def __init__(self, interface_name):
202         PacketVerifier.__init__(self, interface_name)
203         self._sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)
204
205     def recv(self, timeout=3, ignore=None, verbose=True):
206         """Read next received packet.
207
208         Returns scapy's Ether() object created from next packet in the queue.
209         Queue is being filled in parallel in subprocess. If no packet
210         arrives in given timeout queue.Empty exception will be risen.
211
212         :param timeout: How many seconds to wait for next packet.
213         :param ignore: List of packets that should be ignored.
214         :param verbose: Used to suppress detailed logging of received packets.
215         :type timeout: int
216         :type ignore: list
217         :type verbose: bool
218
219         :returns: Ether() initialized object from packet data.
220         :rtype: scapy.Ether
221         """
222         ignore_list = list()
223         if ignore is not None:
224             for ig_pkt in ignore:
225                 # Auto pad all packets in ignore list
226                 ignore_list.append(auto_pad(ig_pkt))
227         while True:
228             (rlist, _, _) = select.select([self._sock], [], [], timeout)
229             if self._sock not in rlist:
230                 return None
231
232             pkt = self._sock.recv(0x7fff)
233             pkt_pad = auto_pad(pkt)
234             print 'Received packet on {0} of len {1}'\
235                 .format(self._ifname, len(pkt))
236             if verbose:
237                 pkt.show2()  # pylint: disable=no-member
238                 print
239             if pkt_pad in ignore_list:
240                 ignore_list.remove(pkt_pad)
241                 print 'Received packet ignored.'
242                 continue
243             else:
244                 return pkt
245
246
247 class TxQueue(PacketVerifier):
248     """Transmission queue object.
249
250     This object is used to send packets over RAW socket on a interface.
251
252     :param interface_name: Which interface to send packets from.
253     :type interface_name: str
254     """
255     def __init__(self, interface_name):
256         PacketVerifier.__init__(self, interface_name)
257         self._sock = conf.L2socket(iface=interface_name, type=ETH_P_ALL)
258
259     def send(self, pkt, verbose=True):
260         """Send packet out of the bound interface.
261
262         :param pkt: Packet to send.
263         :param verbose: Used to supress detailed logging of sent packets.
264         :type pkt: string or scapy Packet derivative.
265         :type verbose: bool
266         """
267         print 'Sending packet out of {0} of len {1}'.format(self._ifname,
268                                                             len(pkt))
269         if verbose:
270             Ether(str(pkt)).show2()
271             print
272
273         pkt = auto_pad(str(pkt))
274         self._sock.send(pkt)
275
276
277 class Interface(object):
278     """Class for network interfaces. Contains methods for sending and receiving
279      packets."""
280     def __init__(self, if_name):
281         """Initialize the interface class.
282
283         :param if_name: Name of the interface.
284         :type if_name: str
285         """
286         self.if_name = if_name
287         self.sent_packets = []
288         self.rxq = RxQueue(if_name)
289         self.txq = TxQueue(if_name)
290
291     def send_pkt(self, pkt):
292         """Send the provided packet out the interface."""
293         self.sent_packets.append(pkt)
294         self.txq.send(pkt)
295
296     def recv_pkt(self, timeout=3):
297         """Read one packet from the interface's receive queue.
298
299         :param timeout: Timeout value in seconds.
300         :type timeout: int
301         :returns: Ether() initialized object from packet data.
302         :rtype: scapy.Ether
303         """
304         return self.rxq.recv(timeout, self.sent_packets)
305
306
307 def create_gratuitous_arp_request(src_mac, src_ip):
308     """Creates scapy representation of gratuitous ARP request."""
309     return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
310             ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
311
312
313 def auto_pad(packet):
314     """Pads zeroes at the end of the packet if the total len < 60 bytes."""
315     padded = str(packet)
316     if len(padded) < 60:
317         padded += ('\0' * (60 - len(padded)))
318     return padded
319
320
321 def checksum_equal(chksum1, chksum2):
322     """Compares two checksums in one's complement notation.
323
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.
328
329     :param chksum1: First checksum.
330     :param chksum2: Second checksum.
331     :type chksum1: uint16
332     :type chksum2: uint16
333
334     :returns: True if checksums are equivalent, False otherwise.
335     :rtype: boolean
336     """
337     if chksum1 == 0xFFFF:
338         chksum1 = 0
339     if chksum2 == 0xFFFF:
340         chksum2 = 0
341     return chksum1 == chksum2

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.