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
  66 import socket
  67 import select
  68 import os
  69 import time
  70 from multiprocessing import Queue, Process
  71 from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
  72 from scapy.all import Ether, ARP, Packet
  73 from scapy.layers.inet6 import IPv6
  74
  75 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',
  76            'auto_pad']
  77
  78 # TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program
  79
  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,
  87                                    ETH_P_ALL)
  88         self._sock.bind((interface_name, ETH_P_ALL))
  89         self._ifname = interface_name
  90
  91
  92 def extract_one_packet(buf):
  93     """Extract one packet from the incoming buf buffer.
  94
  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.
  97
  98     :param buf: string representation of incoming packet buffer.
  99     :type buf: string
 100     :return: String representation of first packet in buf.
 101     :rtype: string
 102     """
 103     pkt_len = 0
 104
 105     if len(buf) < 60:
 106         return None
 107
 108     # print
 109     # print buf.__repr__()
 110     # print Ether(buf).__repr__()
 111     # print len(Ether(buf))
 112     # print
 113     try:
 114         ether_type = Ether(buf[0:14]).type
 115     except AttributeError:
 116         raise RuntimeError(
 117             'No EtherType in packet {0}'.format(buf.__repr__()))
 118
 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
 123         #     header.
 124         pkt_len = Ether(buf[0:14+4]).len + 14
 125         if len(buf) < 60:
 126             return None
 127     elif ether_type == ETH_P_IPV6:
 128         if not Ether(buf[0:14+6]).haslayer(IPv6):
 129             raise RuntimeError(
 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
 134         if len(buf) < 60:
 135             return None
 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)
 142
 143         pkt_len = 14 + 8
 144         pkt_len += 2 * pkt.getlayer(ARP).hwlen
 145         pkt_len += 2 * pkt.getlayer(ARP).plen
 146
 147         del pkt
 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):
 153             pkt.show()
 154             raise RuntimeError('Incomplete RARP packet')
 155
 156         # len(eth) + arp(2 hw addr type + 2 proto addr type
 157         #                + 1b len + 1b len + 2b operation)
 158         pkt_len = 14 + 8
 159         pkt_len += 2 * pkt.getlayer(ARP).hwlen
 160         pkt_len += 2 * pkt.getlayer(ARP).plen
 161
 162         del pkt
 163     else:
 164         raise RuntimeError('Unknown protocol {0}'.format(ether_type))
 165
 166     if pkt_len < 60:
 167         pkt_len = 60
 168
 169     if len(buf) < pkt_len:
 170         return None
 171
 172     return buf[0:pkt_len]
 173
 174
 175 def packet_reader(interface_name, queue):
 176     """Sub-process routine that reads packets and puts them to queue.
 177
 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.
 180
 181     :param interace_name: Name of interface to read packets from.
 182     :param queue: Queue in which this function will push incoming packets.
 183     :type interface_name: string
 184     :type queue: multiprocessing.Queue
 185     :return: None
 186     """
 187     sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
 188     sock.bind((interface_name, ETH_P_ALL))
 189
 190     while True:
 191         pkt = sock.recv(0x7fff)
 192         queue.put(pkt)
 193
 194
 195 class RxQueue(PacketVerifier):
 196     """Receive queue object.
 197
 198     This object creates raw socket, reads packets from it and provides
 199     function to access them.
 200
 201     :param interface_name: Which interface to bind to.
 202     :type interface_name: string
 203     """
 204
 205     def __init__(self, interface_name):
 206         PacketVerifier.__init__(self, interface_name)
 207
 208         #self._queue = Queue()
 209         #self._proc = Process(target=packet_reader, args=(interface_name,
 210         #                                                 self._queue))
 211         #self._proc.daemon = True
 212         #self._proc.start()
 213         #time.sleep(2)
 214
 215     def recv(self, timeout=3, ignore=None):
 216         """Read next received packet.
 217
 218         Returns scapy's Ether() object created from next packet in the queue.
 219         Queue is being filled in parallel in subprocess. If no packet
 220         arrives in given timeout queue.Empty exception will be risen.
 221
 222         :param timeout: How many seconds to wait for next packet.
 223         :type timeout: int
 224
 225         :return: Ether() initialized object from packet data.
 226         :rtype: scapy.Ether
 227         """
 228
 229         #pkt = self._queue.get(True, timeout=timeout)
 230         (rlist, _, _) = select.select([self._sock], [], [], timeout)
 231         if self._sock not in rlist:
 232             return None
 233
 234         pkt = self._sock.recv(0x7fff)
 235         pkt_pad = auto_pad(pkt)
 236         print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
 237         Ether(pkt).show2()
 238         print
 239
 240         if ignore is not None:
 241             for i, ig_pkt in enumerate(ignore):
 242                 # Auto pad all packets in ignore list
 243                 ignore[i] = auto_pad(ig_pkt)
 244             for ig_pkt in ignore:
 245                 if ig_pkt == pkt_pad:
 246                     # Found the packet in ignore list, get another one
 247                     # TODO: subtract timeout - time_spent in here
 248                     ignore.remove(ig_pkt)
 249                     return self.recv(timeout, ignore)
 250
 251         return Ether(pkt)
 252
 253
 254 class TxQueue(PacketVerifier):
 255     """Transmission queue object.
 256
 257     This object is used to send packets over RAW socket on a interface.
 258
 259     :param interface_name: Which interface to send packets from.
 260     :type interface_name: string
 261     """
 262     def __init__(self, interface_name):
 263         PacketVerifier.__init__(self, interface_name)
 264
 265     def send(self, pkt):
 266         """Send packet out of the bound interface.
 267
 268         :param pkt: Packet to send.
 269         :type pkt: string or scapy Packet derivative.
 270         """
 271         print 'Sending packet out of {0} of len {1}'.format(self._ifname,
 272                                                             len(pkt))
 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     def __init__(self, if_name):
 282         self.if_name = if_name
 283         self.sent_packets = []
 284         self.rxq = RxQueue(if_name)
 285         self.txq = TxQueue(if_name)
 286
 287     def send_pkt(self, pkt):
 288         self.sent_packets.append(pkt)
 289         self.txq.send(pkt)
 290
 291     def recv_pkt(self, timeout=3):
 292         return self.rxq.recv(timeout, self.sent_packets)
 293
 294     def close(self):
 295         #self.rxq._proc.terminate()
 296         pass
 297
 298
 299 def create_gratuitous_arp_request(src_mac, src_ip):
 300     """Creates scapy representation of gratuitous ARP request"""
 301     return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') /
 302             ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip))
 303
 304
 305 def auto_pad(packet):
 306     """Pads zeroes at the end of the packet if the total len < 60 bytes."""
 307     padded = str(packet)
 308     if len(padded) < 60:
 309         padded += ('\0' * (60 - len(padded)))
 310     return padded
 311