resources/libraries/python/PacketVerifier.py

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