Merge pull request #2 from secdev/master

Pull

Author: UmakantKulkarni

doc/scapy/index.rst

@@ -25,6 +25,7 @@ This document is under a `Creative Commons Attribution - Non-Commercial
 
    usage
    advanced_usage
+   routing
 
 .. toctree::
    :maxdepth: 2

doc/scapy/routing.rst

@@ -0,0 +1,93 @@
+*************
+Scapy routing
+*************
+
+Scapy needs to know many things related to the network configuration of your machine, to be able to route packets properly. For instance, the interface list, the IPv4 and IPv6 routes...
+
+This means that Scapy has implemented bindings to get this information. Those bindings are OS specific. This will show you how to use it for a different usage.
+
+.. note::
+    Scapy will have OS-specific functions underlying some high level functions. This page ONLY presents the cross platform ones
+
+
+List interfaces
+---------------
+
+Use ``get_if_list()`` to get the interface list
+
+.. code-block:: pycon
+
+    >>> get_if_list()
+    ['lo', 'eth0']
+
+IPv4 routes
+-----------
+
+.. note::
+    If you want to change or edit the routes, have a look at `the "Routing" section in Usage <usage.html#routing>`_
+
+The routes are stores in :py:attr:`conf.route <scapy.route.Route>`. You can use it to display the routes, or get specific routing
+
+.. code-block:: pycon
+
+    >>> conf.route
+
+    Network          Netmask          Gateway   Iface  Output IP  Metric
+    0.0.0.0          0.0.0.0          10.0.0.1  eth0   10.0.0.5   100
+    10.0.0.0         255.255.255.0    0.0.0.0   eth0   10.0.0.5   0
+    127.0.0.0        255.0.0.0        0.0.0.0   lo     127.0.0.1  1
+    168.63.129.16    255.255.255.255  10.0.0.1  eth0   10.0.0.5   100
+    169.254.169.254  255.255.255.255  10.0.0.1  eth0   10.0.0.5   100
+
+Get the route for a specific IP:  :py:func:`conf.route.route() <scapy.route.Route.route>` will return ``(interface, outgoing_ip, gateway)``
+
+.. code-block:: pycon
+
+    >>> conf.route.route("127.0.0.1")
+    ('lo', '127.0.0.1', '0.0.0.0')
+
+IPv6 routes
+-----------
+
+Same than IPv4 but with :py:attr:`conf.route6 <scapy.route6.Route6>`
+
+Get router IP address
+---------------------
+
+.. code-block:: pycon
+
+    >>> gw = conf.route.route("0.0.0.0")[2]
+    >>> gw
+    '10.0.0.1'
+
+Get local IP / IP of an interface
+---------------------------------
+
+Use ``conf.iface``
+
+.. code-block:: pycon
+
+    >>> ip = get_if_addr(conf.iface)  # default interface
+    >>> ip = get_if_addr("eth0")
+    >>> ip
+    '10.0.0.5'
+
+Get local MAC / MAC of an interface
+-----------------------------------
+
+.. code-block:: pycon
+
+    >>> mac = get_if_hwaddr(conf.iface)  # default interface
+    >>> mac = get_if_hwaddr("eth0")
+    >>> mac
+    '54:3f:19:c9:38:6d'
+
+Get MAC by IP
+-------------
+
+.. code-block:: pycon
+
+    >>> mac = getmacbyip("10.0.0.1")
+    >>> mac
+    'f3:ae:5e:76:31:9b'
+

scapy/arch/linux.py

@@ -31,7 +31,7 @@
     SO_TIMESTAMPNS
 from scapy.supersocket import SuperSocket
 from scapy.error import warning, Scapy_Exception, \
-    ScapyInvalidPlatformException
+    ScapyInvalidPlatformException, log_runtime
 from scapy.arch.common import get_if, compile_filter
 import scapy.modules.six as six
 from scapy.modules.six.moves import range
@@ -461,12 +461,19 @@ def __init__(self, iface=None, type=ETH_P_ALL, promisc=None, filter=None,
         )
         if not six.PY2:
             # Receive Auxiliary Data (VLAN tags)
-            self.ins.setsockopt(SOL_PACKET, PACKET_AUXDATA, 1)
-            self.ins.setsockopt(
-                socket.SOL_SOCKET,
-                SO_TIMESTAMPNS,
-                1
-            )
+            try:
+                self.ins.setsockopt(SOL_PACKET, PACKET_AUXDATA, 1)
+                self.ins.setsockopt(
+                    socket.SOL_SOCKET,
+                    SO_TIMESTAMPNS,
+                    1
+                )
+                self.auxdata_available = True
+            except OSError:
+                # Note: Auxiliary Data is only supported since
+                #       Linux 2.6.21
+                msg = "Your Linux Kernel does not support Auxiliary Data!"
+                log_runtime.info(msg)
         if isinstance(self, L2ListenSocket):
             self.outs = None
         else:
@@ -494,7 +501,7 @@ def close(self):
         try:
             if self.promisc and self.ins:
                 set_promisc(self.ins, self.iface, 0)
-        except AttributeError:
+        except (AttributeError, OSError):
             pass
         SuperSocket.close(self)
 

scapy/contrib/automotive/bmw/definitions.py

@@ -1,5 +1,3 @@
-#! /usr/bin/env python
-
 # This file is part of Scapy
 # See http://www.secdev.org/projects/scapy for more information
 # Copyright (C) Nils Weiss <[email protected]>
@@ -11,9 +9,9 @@
 
 from scapy.packet import Packet, bind_layers
 from scapy.fields import ByteField, ShortField, ByteEnumField, X3BytesField, \
-    StrField
+    StrField, StrFixedLenField, LEIntField, LEThreeBytesField, PacketListField
 from scapy.contrib.automotive.uds import UDS, UDS_RDBI, UDS_DSC, UDS_IOCBI, \
-    UDS_RC, UDS_RD, UDS_RSDBI
+    UDS_RC, UDS_RD, UDS_RSDBI, UDS_RDBIPR
 
 
 BMW_specific_enum = {
@@ -245,6 +243,111 @@ class UDS2S_REQ(Packet):
 UDS.services[0xa5] = 'UnpackDS2Service'
 
 
+class SVK_DateField(LEThreeBytesField):
+    def i2repr(self, pkt, x):
+        x = self.addfield(pkt, b"", x)
+        return "%02X.%02X.20%02X" % (x[0], x[1], x[2])
+
+
+class SVK_Entry(Packet):
+    fields_desc = [
+        ByteEnumField("processClass", 0, {1: "HWEL", 2: "HWAP", 4: "GWTB",
+                                          5: "CAFD", 6: "BTLD", 7: "FLSL",
+                                          8: "SWFL"}),
+        StrFixedLenField("svk_id", b"", length=4),
+        ByteField("mainVersion", 0),
+        ByteField("subVersion", 0),
+        ByteField("patchVersion", 0)]
+
+    def extract_padding(self, p):
+        return b"", p
+
+
+class SVK(Packet):
+    prog_status_enum = {
+        1: "signature check and programming-dependencies check passed",
+        2: "software entry invalid or programming-dependencies check failed",
+        3: "software entry incompatible to hardware entry",
+        4: "software entry incompatible with other software entry"}
+
+    fields_desc = [
+        ByteEnumField("prog_status1", 0, prog_status_enum),
+        ByteEnumField("prog_status2", 0, prog_status_enum),
+        ShortField("entries_count", 0),
+        SVK_DateField("prog_date", b'\x00\x00\x00'),
+        ByteField("pad1", 0),
+        LEIntField("prog_milage", 0),
+        StrFixedLenField("pad2", 0, length=5),
+        PacketListField("entries", [], cls=SVK_Entry,
+                        count_from=lambda x: x.entries_count)]
+
+
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf101)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf102)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf103)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf104)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf105)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf106)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf107)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf108)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf109)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10a)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10b)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10c)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10d)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10e)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf10f)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf110)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf111)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf112)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf113)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf114)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf115)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf116)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf117)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf118)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf119)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11a)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11b)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11c)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11d)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11e)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf11f)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf120)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf121)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf122)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf123)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf124)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf125)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf126)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf127)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf128)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf129)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12a)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12b)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12c)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12d)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12e)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf12f)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf130)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf131)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf132)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf133)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf134)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf135)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf136)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf137)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf138)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf139)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13a)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13b)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13c)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13d)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13e)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf13f)
+bind_layers(UDS_RDBIPR, SVK, dataIdentifier=0xf140)
+
+
 UDS_RDBI.dataIdentifiers[0x0014] = "RDBCI_IS_LESEN_DETAIL_REQ"
 UDS_RDBI.dataIdentifiers[0x0015] = "RDBCI_HS_LESEN_DETAIL_REQ"
 UDS_RDBI.dataIdentifiers[0x0e80] = "AirbagLock"

scapy/contrib/automotive/bmw/enet.py

@@ -13,6 +13,9 @@
 from scapy.layers.inet import TCP
 from scapy.supersocket import StreamSocket
 from scapy.contrib.automotive.uds import UDS
+from scapy.contrib.isotp import ISOTP
+from scapy.error import Scapy_Exception
+from scapy.data import MTU
 
 
 """
@@ -65,6 +68,28 @@ def post_build(self, pkt, pay):
 
 class ENETSocket(StreamSocket):
     def __init__(self, ip='127.0.0.1', port=6801):
+        self.ip = ip
+        self.port = port
         s = socket.socket()
-        s.connect((ip, port))
+        s.connect((self.ip, self.port))
         StreamSocket.__init__(self, s, ENET)
+
+
+class ISOTP_ENETSocket(ENETSocket):
+    def __init__(self, src, dst, ip='127.0.0.1', port=6801, basecls=ISOTP):
+        super(ISOTP_ENETSocket, self).__init__(ip, port)
+        self.src = src
+        self.dst = dst
+        self.basecls = ENET
+        self.outputcls = basecls
+
+    def send(self, x):
+        if not isinstance(x, ISOTP):
+            raise Scapy_Exception("Please provide a packet class based on "
+                                  "ISOTP")
+        super(ISOTP_ENETSocket, self).send(
+            ENET(src=self.src, dst=self.dst) / x)
+
+    def recv(self, x=MTU):
+        pkt = super(ISOTP_ENETSocket, self).recv(x)
+        return self.outputcls(bytes(pkt[1]))

scapy/contrib/http2.py

@@ -2644,24 +2644,25 @@ def parse_txt_hdrs(self,
                        register=True,  # type: bool
                        ):
         # type: (...) -> H2Seq
-        """ parse_txt_hdrs parses headers expressed in text and converts them
-        into a series of H2Frames with the "correct" flags. A body can be provided  # noqa: E501
-        in which case, the data frames are added, bearing the End Stream flag,
-        instead of the H2HeadersFrame/H2ContinuationFrame. The generated frames
-        may respect max_frm_sz (SETTINGS_MAX_FRAME_SIZE) and
-        max_hdr_lst_sz (SETTINGS_MAX_HEADER_LIST_SIZE) if provided. The headers
-        are split into multiple headers fragment (and H2Frames) to respect
-        these limits. Also, a callback can be provided to tell if a header
-        should be never indexed (sensitive headers, such as cookies), and
-        another callback say if the header should be registered into the index
-        table at all.
+        """
+        parse_txt_hdrs parses headers expressed in text and converts them
+        into a series of H2Frames with the "correct" flags. A body can be
+        provided in which case, the data frames are added, bearing the End
+        Stream flag, instead of the H2HeadersFrame/H2ContinuationFrame.
+        The generated frames may respect max_frm_sz (SETTINGS_MAX_FRAME_SIZE)
+        and max_hdr_lst_sz (SETTINGS_MAX_HEADER_LIST_SIZE) if provided.
+        The headers are split into multiple headers fragment (and H2Frames)
+        to respect these limits. Also, a callback can be provided to tell if
+        a header should be never indexed (sensitive headers, such as cookies),
+        and another callback say if the header should be registered into the
+        index table at all.
         For an header to be registered, the is_sensitive callback must return
         False AND the should_index callback should return True. This is the
         default behavior.
 
         :param str s: the string to parse for headers
         :param int stream_id: the stream id to use in the generated H2Frames
-        :param str|None body: the eventual body of the request, that is added
+        :param str/None body: the eventual body of the request, that is added
           to the generated frames
         :param int max_frm_sz: the maximum frame size. This is used to split
           the headers and data frames according to the maximum frame size