Merge pull request #1088 from gpotter2/ipv6-fixes

SEND module fixes & Stuff

Author: p-l-

scapy/arch/__init__.py

@@ -14,7 +14,7 @@
     SOLARIS, WINDOWS, BSD, IS_64BITS, LOOPBACK_NAME
 from scapy.error import *
 import scapy.config
-from scapy.pton_ntop import inet_pton
+from scapy.pton_ntop import inet_pton, inet_ntop
 from scapy.data import *
 
 def str2mac(s):
@@ -25,7 +25,7 @@ def str2mac(s):
         from scapy.arch.bpf.core import get_if_raw_addr
 
 def get_if_addr(iff):
-    return socket.inet_ntoa(get_if_raw_addr(iff))
+    return inet_ntop(socket.AF_INET, get_if_raw_addr(iff))
 
 def get_if_hwaddr(iff):
     addrfamily, mac = get_if_raw_hwaddr(iff)

scapy/contrib/send.py

@@ -15,77 +15,67 @@
 # along with Scapy. If not, see <http://www.gnu.org/licenses/>.
 
 ## Copyright (C) 2009 Adline Stephane <adline.stephane@gmail.com>
-##
+## Copyright     2018 Gabriel Potter <gabriel@potter.fr>
 
 # Partial support of RFC3971
-# scapy.contrib.description = SEND (ICMPv6)
+# scapy.contrib.description = Secure Neighbor Discovery (SEND) (ICMPv6)
 # scapy.contrib.status = loads
 
 from __future__ import absolute_import
 import socket
 
 from scapy.packet import *
 from scapy.fields import *
-from scapy.layers.inet6 import icmp6typescls, _ICMPv6NDGuessPayload, Net6
-
-send_icmp6typescls = { 11: "ICMPv6NDOptCGA",
-                       12: "ICMPv6NDOptRsaSig",
-                       13: "ICMPv6NDOptTmstp",
-                       14: "ICMPv6NDOptNonce"
-                     }
-icmp6typescls.update(send_icmp6typescls)
-
-class HashField(Field):
-    def __init__(self, name, default):
-        Field.__init__(self, name, default, "16s")
-    def h2i(self, pkt, x):
-        if isinstance(x, str):
-            try:
-                x = in6_ptop(x)
-            except socket.error:
-                x = Net6(x)
-        elif isinstance(x, list):
-            x = [Net6(e) for e in x]
-        return x
-    def i2m(self, pkt, x):
-        return inet_pton(socket.AF_INET6, x)
-    def m2i(self, pkt, x):
-        return inet_ntop(socket.AF_INET6, x)
-    def any2i(self, pkt, x):
-        return self.h2i(pkt,x)
-    def i2repr(self, pkt, x):
-        return self.i2h(pkt, x)    # No specific information to return
+from scapy.layers.x509 import X509_SubjectPublicKeyInfo
+from scapy.layers.inet6 import icmp6ndoptscls, _ICMPv6NDGuessPayload
 
 class ICMPv6NDOptNonce(_ICMPv6NDGuessPayload, Packet):
     name = "ICMPv6NDOptNonce"
     fields_desc = [ ByteField("type",14),
-                    FieldLenField("len",None,length_of="data",fmt="B", adjust = lambda pkt,x: (x)/8),
-                    StrLenField("nonce","", length_from = lambda pkt: pkt.len*8-2) ]
+                    FieldLenField("len", None, length_of="nonce", fmt="B", adjust = lambda pkt,x: int(round((x+2)/8.))),
+                    StrLenField("nonce", "", length_from = lambda pkt: pkt.len*8-2) ]
 
 class ICMPv6NDOptTmstp(_ICMPv6NDGuessPayload, Packet):
     name = "ICMPv6NDOptTmstp"
     fields_desc = [ ByteField("type",13),
-                    ByteField("len",2),
+                    ByteField("len", 2),
                     BitField("reserved",0, 48),
-                    LongField("timestamp", None) ]
+                    UTCTimeField("timestamp", None) ]
 
 class ICMPv6NDOptRsaSig(_ICMPv6NDGuessPayload, Packet):
     name = "ICMPv6NDOptRsaSig"
     fields_desc = [ ByteField("type",12),
-                    FieldLenField("len",None,length_of="data",fmt="B", adjust = lambda pkt,x: (x)/8),
+                    FieldLenField("len", None, length_of="signature_pad", fmt="B", adjust = lambda pkt,x: (x+20)//8),
                     ShortField("reserved",0),
-                    HashField("key_hash",None),
+                    StrFixedLenField("key_hash", "", length=16),
                     StrLenField("signature_pad", "", length_from = lambda pkt: pkt.len*8-20) ]
 
+class CGA_Params(Packet):
+    name = "CGA Parameters data structure"
+    fields_desc = [ StrFixedLenField("modifier", RandBin(size=16), length=16),
+                    StrFixedLenField("subprefix", "", length=8),
+                    ByteField("cc", 0),
+                    PacketField("pubkey", X509_SubjectPublicKeyInfo(),
+                                          X509_SubjectPublicKeyInfo)  ]
+
 class ICMPv6NDOptCGA(_ICMPv6NDGuessPayload, Packet):
     name = "ICMPv6NDOptCGA"
     fields_desc = [ ByteField("type",11),
-                    FieldLenField("len",None,length_of="data",fmt="B", adjust = lambda pkt,x: (x)/8),
-                    ByteField("padlength",0),
+                    FieldLenField("len", None, length_of="CGA_PARAMS", fmt="B", adjust = lambda pkt,x: (x+pkt.padlength+4)//8),
+                    FieldLenField("padlength", 0, length_of="padding", fmt="B"),
                     ByteField("reserved",0),
-                    StrLenField("CGA_PARAMS", "", length_from = lambda pkt: pkt.len*8 - pkt.padlength - 4),
-                    StrLenField("padding", None, length_from = lambda pkt: pkt.padlength) ]
+                    PacketLenField("CGA_PARAMS", "", CGA_Params, length_from = lambda pkt: pkt.len*8 - pkt.padlength - 4),
+                    StrLenField("padding", "", length_from = lambda pkt: pkt.padlength) ]
+
+    def post_build(self, p, pay):
+        l_ = len(self.CGA_PARAMS)
+        l = -(4+l_) % 8  # Pad to 8 bytes
+        p = p[:1] + chb((4+l_+l)//8) + chb(l) + p[3:4+l_] + b"\x00" * l + pay
+        return p
 
-if __name__ == "__main__":
-    from scapy.all import *
-    interact(mydict=globals(), mybanner="SEND add-on")
+send_icmp6ndoptscls = { 11: ICMPv6NDOptCGA,
+                       12: ICMPv6NDOptRsaSig,
+                       13: ICMPv6NDOptTmstp,
+                       14: ICMPv6NDOptNonce
+                     }
+icmp6ndoptscls.update(send_icmp6ndoptscls)

scapy/contrib/send.uts

@@ -0,0 +1,35 @@
++ SEND (IPv6) tests
+
+= ICMPv6NDOptRsaSig build and dissection
+
+pkt = Ether()/IPv6()/ICMPv6ND_NS()/ICMPv6NDOptRsaSig(signature_pad = b"\x01" * 12)
+pkt = Ether(raw(pkt))
+
+assert ICMPv6NDOptRsaSig in pkt
+assert pkt[ICMPv6NDOptRsaSig].signature_pad == b"\x01" * 12
+
+= ICMPv6NDOptCGA build and dissection
+
+pkt = Ether()/IPv6()/ICMPv6ND_NS()/ICMPv6NDOptCGA(CGA_PARAMS=CGA_Params())
+pkt = Ether(raw(pkt))
+
+assert ICMPv6NDOptCGA in pkt
+assert isinstance(pkt[ICMPv6NDOptCGA].CGA_PARAMS.pubkey, X509_SubjectPublicKeyInfo)
+assert len(pkt) == 142
+
+= ICMPv6NDOptTmstp build and dissection
+
+pkt = Ether()/IPv6()/ICMPv6ND_NS()/ICMPv6NDOptTmstp(timestamp=int(time.mktime(time.gmtime())))
+pkt = Ether(raw(pkt))
+pkt.show()
+
+assert ICMPv6NDOptTmstp in pkt
+assert pkt[ICMPv6NDOptTmstp].len == 2
+
+= ICMPv6NDOptNonce build and dissection
+
+pkt = Ether()/IPv6()/ICMPv6ND_NS()/ICMPv6NDOptNonce(nonce=b"\x31\x32\x33\x34\x35\x36")
+pkt = Ether(raw(pkt))
+
+assert ICMPv6NDOptNonce in pkt
+assert raw(ICMPv6NDOptNonce(nonce=b"\x31\x32\x33\x34\x35\x36")) == b'\x0e\x01123456'

scapy/layers/inet6.py

@@ -75,15 +75,6 @@
     # unused import, only to initialize conf.route6
     import scapy.route6
 
-
-#############################################################################
-# Helpers                                                                  ##
-#############################################################################
-
-def get_cls(name, fallback_cls):
-    return globals().get(name, fallback_cls)
-
-
 ##########################
 ## Neighbor cache stuff ##
 ##########################
@@ -403,13 +394,13 @@ def default_payload_class(self,p):
                 if t == 130 and len(p) >= 28:
                     # RFC 3810 - 8.1. Query Version Distinctions
                     return ICMPv6MLQuery2
-                return get_cls(icmp6typescls.get(t, "Raw"), "Raw")
+                return icmp6typescls.get(t,Raw)
             return Raw
         elif self.nh == 135 and len(p) > 3: # Mobile IPv6
             return _mip6_mhtype2cls.get(orb(p[2]), MIP6MH_Generic)
         elif self.nh == 43 and orb(p[2]) == 4:  # Segment Routing header
             return IPv6ExtHdrSegmentRouting
-        return get_cls(ipv6nhcls.get(self.nh, "Raw"), "Raw")
+        return ipv6nhcls.get(self.nh, Raw)
 
 class IPv6(_IPv6GuessPayload, Packet, IPTools):
     name = "IPv6"
@@ -1747,10 +1738,10 @@ def extract_padding(self, s):
                    8: "ICMPv6NDOptHAInfo",
                    9: "ICMPv6NDOptSrcAddrList",
                   10: "ICMPv6NDOptTgtAddrList",
-                  #11: Do Me,
-                  #12: Do Me,
-                  #13: Do Me,
-                  #14: Do Me,
+                  #11: ICMPv6NDOptCGA, RFC3971 - contrib/send.py
+                  #12: ICMPv6NDOptRsaSig, RFC3971 - contrib/send.py
+                  #13: ICMPv6NDOptTmstp, RFC3971 - contrib/send.py
+                  #14: ICMPv6NDOptNonce, RFC3971 - contrib/send.py
                   #15: Do Me,
                   #16: Do Me,
                   17: "ICMPv6NDOptIPAddr",
@@ -1772,7 +1763,7 @@ class _ICMPv6NDGuessPayload:
     name = "Dummy ND class that implements guess_payload_class()"
     def guess_payload_class(self,p):
         if len(p) > 1:
-            return get_cls(icmp6ndoptscls.get(orb(p[0]),"Raw"), "Raw") # s/Raw/ICMPv6NDOptUnknown/g ?
+            return icmp6ndoptscls.get(orb(p[0]), Raw) # s/Raw/ICMPv6NDOptUnknown/g ?
 
 
 # Beginning of ICMPv6 Neighbor Discovery Options.
@@ -4006,6 +3997,20 @@ def ra_reply_callback(req, iface):
           prn=lambda x: ra_reply_callback(x, iface),
           iface=iface)
 
+#############################################################################
+# Pre-load classes                                                         ##
+#############################################################################
+
+def _get_cls(name):
+    return globals().get(name, Raw)
+
+def _load_dict(d):
+    for k, v in d.items():
+        d[k] = _get_cls(v)
+
+_load_dict(icmp6ndoptscls)
+_load_dict(icmp6typescls)
+_load_dict(ipv6nhcls)
 
 #############################################################################
 #############################################################################

scapy/volatile.py

@@ -70,7 +70,7 @@ def next(self):
     __next__ = next
 
 
-class VolatileValue:
+class VolatileValue(object):
     def __repr__(self):
         return "<%s>" % self.__class__.__name__
     def __eq__(self, other):
@@ -266,36 +266,33 @@ def _fix(self):
         return random.choice(self._choice)
 
 class RandString(RandField):
-    def __init__(self, size=None, chars="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"):
+    def __init__(self, size=None, chars=b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"):
         if size is None:
             size = RandNumExpo(0.01)
         self.size = size
         self.chars = chars
     def _fix(self):
-        s = ""
+        s = b""
         for _ in range(self.size):
-            s += random.choice(self.chars)
+            s += chb(random.choice(self.chars))
         return s
+    def __str__(self):
+        return plain_str(self._fix())
+    def __bytes__(self):
+        return raw(self._fix())
     def __mul__(self, n):
         return self._fix()*n
 
 class RandBin(RandString):
     def __init__(self, size=None):
-        RandString.__init__(self, size, "".join(map(chr, range(256))))
+        super(RandBin, self).__init__(size=size, chars=b"".join(chb(c) for c in range(256)))
 
-
-class RandTermString(RandString):
+class RandTermString(RandBin):
     def __init__(self, size, term):
-        RandString.__init__(self, size, "".join(map(chr, range(1,256))))
-        self.term = term
+        self.term = raw(term)
+        super(RandTermString, self).__init__(size=size)
     def _fix(self):
-        return RandString._fix(self)+self.term
-
-    def __str__(self):
-        return str(self._fix())
-
-    def __bytes__(self):
-        return raw(self._fix())
+        return RandBin._fix(self)+self.term
 
 
 class RandIP(RandString):

test/regression.uts

@@ -9008,7 +9008,7 @@ assert(rss == ("CON:" if six.PY2 else "foo.exe:"))
 
 random.seed(0x2807)
 rts = RandTermString(4, "scapy")
-assert(sane(raw(rts)) in ["...[scapy", "......scapy"])
+assert(sane(raw(rts)) in ["...Zscapy", "$#..scapy"])
 
 
 ############