aboutsummaryrefslogtreecommitdiffstats
path: root/GPL/traffic_scripts/PacketVerifier.py
blob: e05084d66c4109bd911e0c9c0906dc5156337b03 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
# Copyright (c) 2020 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""PacketVerifier module.

  Example. ::

    | >>> from scapy.all import *
    | >>> from PacketVerifier import *
    | >>> rxq = RxQueue('eth1')
    | >>> txq = TxQueue('eth1')
    | >>> src_mac = "AA:BB:CC:DD:EE:FF"
    | >>> dst_mac = "52:54:00:ca:5d:0b"
    | >>> src_ip = "11.11.11.10"
    | >>> dst_ip = "11.11.11.11"
    | >>> sent_packets = []
    | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
    | ... IP(src=src_ip, dst=dst_ip) /
    | ... ICMP()
    | >>> sent_packets.append(pkt_send)
    | >>> txq.send(pkt_send)
    | >>> pkt_send = Ether(src=src_mac, dst=dst_mac) /
    | ... ARP(hwsrc=src_mac, psrc=src_ip, hwdst=dst_mac, pdst=dst_ip, op=2)
    | >>> sent_packets.append(pkt_send)
    | >>> txq.send(pkt_send)
    | >>> rxq.recv(100, sent_packets).show()
    | ###[ Ethernet ]###
    |   dst       = aa:bb:cc:dd:ee:ff
    |   src       = 52:54:00:ca:5d:0b
    |   type      = 0x800
    | ###[ IP ]###
    |   version   = 4L
    |   ihl       = 5L
    |   tos       = 0x0
    |   len       = 28
    |   id        = 43183
    |   flags     =
    |   frag      = 0L
    |   ttl       = 64
    |   proto     = icmp
    |   chksum    = 0xa607
    |   src       = 11.11.11.11
    |   dst       = 11.11.11.10
    |   options
    | ###[ ICMP ]###
    |   type      = echo-reply
    |   code      = 0
    |   chksum    = 0xffff
    |   id        = 0x0
    |   seq       = 0x0
    | ###[ Padding ]###
    |   load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'

  Example end.
"""

import os
import select

from scapy.all import ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP
from scapy.config import conf
from scapy.layers.inet6 import IPv6
from scapy.layers.l2 import Ether, ARP
from scapy.packet import Raw, Padding

# Enable libpcap's L2listen
conf.use_pcap = True

__all__ = [
    u"RxQueue", u"TxQueue", u"Interface", u"create_gratuitous_arp_request",
    u"auto_pad", u"checksum_equal"
]

# TODO: http://stackoverflow.com/questions/320232/
# ensuring-subprocesses-are-dead-on-exiting-python-program


class PacketVerifier:
    """Base class for TX and RX queue objects for packet verifier."""
    def __init__(self, interface_name):
        os.system(
            f"sudo echo 1 > /proc/sys/net/ipv6/conf/{interface_name}/"
            f"disable_ipv6"
        )
        os.system(f"sudo ip link set {interface_name} up promisc on")
        self._ifname = interface_name


def extract_one_packet(buf):
    """Extract one packet from the incoming buf buffer.

    Takes string as input and looks for first whole packet in it.
    If it finds one, it returns substring from the buf parameter.

    :param buf: String representation of incoming packet buffer.
    :type buf: str
    :returns: String representation of first packet in buf.
    :rtype: str
    """
    pkt_len = 0

    if len(buf) < 60:
        return None

    try:
        ether_type = Ether(buf[0:14]).type
    except AttributeError:
        raise RuntimeError(f"No EtherType in packet {buf!r}")

    if ether_type == ETH_P_IP:
        # 14 is Ethernet fame header size.
        # 4 bytes is just enough to look for length in ip header.
        # ip total length contains just the IP packet length so add the Ether
        #     header.
        pkt_len = Ether(buf[0:14+4]).len + 14
        if len(buf) < 60:
            return None
    elif ether_type == ETH_P_IPV6:
        if not Ether(buf[0:14+6]).haslayer(IPv6):
            raise RuntimeError(f"Invalid IPv6 packet {buf!r}")
        # ... to add to the above, 40 bytes is the length of IPV6 header.
        #   The ipv6.len only contains length of the payload and not the header
        pkt_len = Ether(buf)[u"IPv6"].plen + 14 + 40
        if len(buf) < 60:
            return None
    elif ether_type == ETH_P_ARP:
        pkt = Ether(buf[:20])
        if not pkt.haslayer(ARP):
            raise RuntimeError(u"Incomplete ARP packet")
        # len(eth) + arp(2 hw addr type + 2 proto addr type
        #                + 1b len + 1b len + 2b operation)

        pkt_len = 14 + 8
        pkt_len += 2 * pkt.getlayer(ARP).hwlen
        pkt_len += 2 * pkt.getlayer(ARP).plen

        del pkt
    elif ether_type == 32821:  # RARP (Reverse ARP)
        pkt = Ether(buf[:20])
        pkt.type = ETH_P_ARP  # Change to ARP so it works with scapy
        pkt = Ether(pkt)
        if not pkt.haslayer(ARP):
            pkt.show()
            raise RuntimeError(u"Incomplete RARP packet")

        # len(eth) + arp(2 hw addr type + 2 proto addr type
        #                + 1b len + 1b len + 2b operation)
        pkt_len = 14 + 8
        pkt_len += 2 * pkt.getlayer(ARP).hwlen
        pkt_len += 2 * pkt.getlayer(ARP).plen

        del pkt
    else:
        raise RuntimeError(f"Unknown protocol {ether_type}")

    if pkt_len < 60:
        pkt_len = 60

    if len(buf) < pkt_len:
        return None

    return buf[0:pkt_len]


def packet_reader(interface_name, queue):
    """Sub-process routine that reads packets and puts them to queue.

    This function is meant to be run in separate subprocess and is in tight
    loop reading raw packets from interface passed as parameter.

    :param interface_name: Name of interface to read packets from.
    :param queue: Queue in which this function will push incoming packets.
    :type interface_name: str
    :type queue: multiprocessing.Queue
    """
    sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)

    while True:
        pkt = sock.recv(0x7fff)
        queue.put(pkt)


class RxQueue(PacketVerifier):
    """Receive queue object.

    This object creates raw socket, reads packets from it and provides
    function to access them.

    :param interface_name: Which interface to bind to.
    :type interface_name: str
    """
    def __init__(self, interface_name):
        PacketVerifier.__init__(self, interface_name)
        self._sock = conf.L2listen(iface=interface_name, type=ETH_P_ALL)

    def recv(self, timeout=3, ignore=None, verbose=True):
        """Read next received packet.

        Returns scapy's Ether() object created from next packet in the queue.
        Queue is being filled in parallel in subprocess. If no packet
        arrives in given timeout None is returned.

        If the list of packets to ignore is given, they are logged
        but otherwise ignored upon arrival, not adding to the timeout.
        Each time a packet is ignored, it is removed from the ignored list.

        :param timeout: How many seconds to wait for next packet.
        :param ignore: List of packets that should be ignored.
        :param verbose: Used to suppress detailed logging of received packets.
        :type timeout: int
        :type ignore: list
        :type verbose: bool

        :returns: Ether() initialized object from packet data.
        :rtype: scapy.Ether
        """
        time_end = time.monotonic() + timeout
        ignore = ignore if ignore else list()
        # Auto pad all packets in ignore list
        ignore = [str(auto_pad(ig_pkt)) for ig_pkt in ignore]
        while 1:
            time_now = time.monotonic()
            if time_now >= time_end:
                return None
            timedelta = time_end - time_now
            rlist, _, _ = select.select([self._sock], [], [], timedelta)
            if self._sock not in rlist:
                # Might have been an interrupt.
                continue
            pkt = self._sock.recv(0x7fff)
            pkt_pad = str(auto_pad(pkt))
            print(f"Received packet on {self._ifname} of len {len(pkt)}")
            if verbose:
                if hasattr(pkt, u"show2"):
                    pkt.show2()
                else:
                    # Never happens in practice, but Pylint does not know that.
                    print(f"Unexpected instance: {pkt!r}")
                print()
            if pkt_pad in ignore:
                ignore.remove(pkt_pad)
                print(u"Received packet ignored.")
                continue
            return pkt


class TxQueue(PacketVerifier):
    """Transmission queue object.

    This object is used to send packets over RAW socket on a interface.

    :param interface_name: Which interface to send packets from.
    :type interface_name: str
    """
    def __init__(self, interface_name):
        PacketVerifier.__init__(self, interface_name)
        self._sock = conf.L2socket(iface=interface_name, type=ETH_P_ALL)

    def send(self, pkt, verbose=True):
        """Send packet out of the bound interface.

        :param pkt: Packet to send.
        :param verbose: Used to suppress detailed logging of sent packets.
        :type pkt: string or scapy Packet derivative.
        :type verbose: bool
        """
        pkt = auto_pad(pkt)
        print(f"Sending packet out of {self._ifname} of len {len(pkt)}")
        if verbose:
            pkt.show2()
            print()

        self._sock.send(pkt)


class Interface:
    """Class for network interfaces. Contains methods for sending and receiving
     packets."""
    def __init__(self, if_name):
        """Initialize the interface class.

        :param if_name: Name of the interface.
        :type if_name: str
        """
        self.if_name = if_name
        self.sent_packets = []
        self.rxq = RxQueue(if_name)
        self.txq = TxQueue(if_name)

    def send_pkt(self, pkt):
        """Send the provided packet out the interface."""
        self.sent_packets.append(pkt)
        self.txq.send(pkt)

    def recv_pkt(self, timeout=3):
        """Read one packet from the interface's receive queue.

        :param timeout: Timeout value in seconds.
        :type timeout: int
        :returns: Ether() initialized object from packet data.
        :rtype: scapy.Ether
        """
        return self.rxq.recv(timeout, self.sent_packets)


def create_gratuitous_arp_request(src_mac, src_ip):
    """Creates scapy representation of gratuitous ARP request."""
    return (Ether(src=src_mac, dst=u"ff:ff:ff:ff:ff:ff") /
            ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip)
            )


def auto_pad(packet):
    """Pads zeroes at the end of the packet if the total packet length is less
    then 64 bytes in case of IPv4 or 78 bytes in case of IPv6.
    """
    min_len = 78 if packet.haslayer(IPv6) else 64
    pad_layer = Raw if packet.haslayer(Raw) \
        else Padding if packet.haslayer(Padding) else None
    if pad_layer:
        packet[pad_layer].load += (b"\0" * (min_len - len(packet)))
    return packet


def checksum_equal(chksum1, chksum2):
    """Compares two checksums in one's complement notation.

    Checksums to be compared are calculated as 16 bit one's complement of the
    one's complement sum of 16 bit words of some buffer.
    In one's complement notation 0x0000 (positive zero) and 0xFFFF
    (negative zero) are equivalent.

    :param chksum1: First checksum.
    :param chksum2: Second checksum.
    :type chksum1: uint16
    :type chksum2: uint16

    :returns: True if checksums are equivalent, False otherwise.
    :rtype: boolean
    """
    if chksum1 == 0xFFFF:
        chksum1 = 0
    if chksum2 == 0xFFFF:
        chksum2 = 0
    return chksum1 == chksum2