ASN.1: minor cleanup + LDAP/KRB bug fixes (#4306)

Author: gpotter2

scapy/asn1/ber.py

@@ -15,6 +15,7 @@
 from scapy.compat import chb, orb, bytes_encode
 from scapy.utils import binrepr, inet_aton, inet_ntoa
 from scapy.asn1.asn1 import (
+    ASN1Tag,
     ASN1_BADTAG,
     ASN1_BadTag_Decoding_Error,
     ASN1_Class,
@@ -216,14 +217,15 @@ def BER_id_enc(n):
 
 
 def BER_tagging_dec(s,  # type: bytes
-                    hidden_tag=None,  # type: Optional[Any]
+                    hidden_tag=None,  # type: Optional[int | ASN1Tag]
                     implicit_tag=None,  # type: Optional[int]
                     explicit_tag=None,  # type: Optional[int]
                     safe=False,  # type: Optional[bool]
                     _fname="",  # type: str
                     ):
     # type: (...) -> Tuple[Optional[int], bytes]
     # We output the 'real_tag' if it is different from the (im|ex)plicit_tag.
+    # 'hidden_tag' is the type tag that is implicited when 'implicit_tag' is used.
     real_tag = None
     if len(s) > 0:
         err_msg = (
@@ -233,13 +235,13 @@ def BER_tagging_dec(s,  # type: bytes
         if implicit_tag is not None:
             ber_id, s = BER_id_dec(s)
             if ber_id != implicit_tag:
-                if not safe and ber_id & 0x1f != implicit_tag & 0x1f:
+                if not safe and ber_id != implicit_tag:
                     raise BER_Decoding_Error(err_msg % (
                         ber_id, implicit_tag, _fname),
                         remaining=s)
                 else:
                     real_tag = ber_id
-            s = chb(hash(hidden_tag)) + s
+            s = chb(int(hidden_tag)) + s  # type: ignore
         elif explicit_tag is not None:
             ber_id, s = BER_id_dec(s)
             if ber_id != explicit_tag:
@@ -253,11 +255,11 @@ def BER_tagging_dec(s,  # type: bytes
     return real_tag, s
 
 
-def BER_tagging_enc(s, hidden_tag=None, implicit_tag=None, explicit_tag=None):
-    # type: (bytes, Optional[Any], Optional[int], Optional[int]) -> bytes
+def BER_tagging_enc(s, implicit_tag=None, explicit_tag=None):
+    # type: (bytes, Optional[int], Optional[int]) -> bytes
     if len(s) > 0:
         if implicit_tag is not None:
-            s = BER_id_enc((hash(hidden_tag) & ~(0x1f)) | implicit_tag) + s[1:]
+            s = BER_id_enc(implicit_tag) + s[1:]
         elif explicit_tag is not None:
             s = BER_id_enc(explicit_tag) + BER_len_enc(len(s)) + s
     return s
@@ -424,9 +426,9 @@ def enc(cls, i, size_len=0):
             i >>= 8
             if not i:
                 break
-        s = [chb(hash(c)) for c in ls]
+        s = [chb(int(c)) for c in ls]
         s.append(BER_len_enc(len(s), size=size_len))
-        s.append(chb(hash(cls.tag)))
+        s.append(chb(int(cls.tag)))
         s.reverse()
         return b"".join(s)
 
@@ -495,7 +497,7 @@ def enc(cls, _s, size_len=0):
         s = b"".join(chb(int(b"".join(chb(y) for y in x), 2))
                      for x in zip(*[iter(s)] * 8))
         s = chb(unused_bits) + s
-        return chb(hash(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
+        return chb(int(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
 
 
 class BERcodec_STRING(BERcodec_Object[str]):
@@ -506,7 +508,7 @@ def enc(cls, _s, size_len=0):
         # type: (Union[str, bytes], Optional[int]) -> bytes
         s = bytes_encode(_s)
         # Be sure we are encoding bytes
-        return chb(hash(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
+        return chb(int(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
 
     @classmethod
     def do_dec(cls,
@@ -526,7 +528,7 @@ class BERcodec_NULL(BERcodec_INTEGER):
     def enc(cls, i, size_len=0):
         # type: (int, Optional[int]) -> bytes
         if i == 0:
-            return chb(hash(cls.tag)) + b"\0"
+            return chb(int(cls.tag)) + b"\0"
         else:
             return super(cls, cls).enc(i, size_len=size_len)
 
@@ -546,7 +548,7 @@ def enc(cls, _oid, size_len=0):
             lst[1] += 40 * lst[0]
             del lst[0]
         s = b"".join(BER_num_enc(k) for k in lst)
-        return chb(hash(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
+        return chb(int(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
 
     @classmethod
     def do_dec(cls,
@@ -631,7 +633,7 @@ def enc(cls, _ll, size_len=0):
             ll = _ll
         else:
             ll = b"".join(x.enc(cls.codec) for x in _ll)
-        return chb(hash(cls.tag)) + BER_len_enc(len(ll), size=size_len) + ll
+        return chb(int(cls.tag)) + BER_len_enc(len(ll), size=size_len) + ll
 
     @classmethod
     def do_dec(cls,
@@ -678,7 +680,7 @@ def enc(cls, ipaddr_ascii, size_len=0):  # type: ignore
             s = inet_aton(ipaddr_ascii)
         except Exception:
             raise BER_Encoding_Error("IPv4 address could not be encoded")
-        return chb(hash(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
+        return chb(int(cls.tag)) + BER_len_enc(len(s), size=size_len) + s
 
     @classmethod
     def do_dec(cls, s, context=None, safe=False):

scapy/asn1fields.py

@@ -110,8 +110,8 @@ def __init__(self,
         if (implicit_tag is not None) and (explicit_tag is not None):
             err_msg = "field cannot be both implicitly and explicitly tagged"
             raise ASN1_Error(err_msg)
-        self.implicit_tag = implicit_tag
-        self.explicit_tag = explicit_tag
+        self.implicit_tag = implicit_tag and int(implicit_tag)
+        self.explicit_tag = explicit_tag and int(explicit_tag)
         # network_tag gets useful for ASN1F_CHOICE
         self.network_tag = int(implicit_tag or explicit_tag or self.ASN1_tag)
         self.owners = []  # type: List[Type[ASN1_Packet]]
@@ -173,7 +173,7 @@ def i2m(self, pkt, x):
                 raise ASN1_Error("Encoding Error: got %r instead of an %r for field [%s]" % (x, self.ASN1_tag, self.name))  # noqa: E501
         else:
             s = self.ASN1_tag.get_codec(pkt.ASN1_codec).enc(x, size_len=self.size_len)
-        return BER_tagging_enc(s, hidden_tag=self.ASN1_tag,
+        return BER_tagging_enc(s,
                                implicit_tag=self.implicit_tag,
                                explicit_tag=self.explicit_tag)
 
@@ -709,8 +709,6 @@ def __init__(self, name, default, *args, **kwargs):
                 else:
                     # should be ASN1F_field instance
                     self.choices[p.network_tag] = p
-                    if p.implicit_tag is not None:
-                        self.choices[p.implicit_tag & 0x1f] = p
                     self.pktchoices[hash(p.cls)] = (p.implicit_tag, p.explicit_tag)  # noqa: E501
             else:
                 raise ASN1_Error("ASN1F_CHOICE: no tag found for one field")
@@ -729,9 +727,7 @@ def m2i(self, pkt, s):
         if tag in self.choices:
             choice = self.choices[tag]
         else:
-            if tag & 0x1f in self.choices:  # Try resolve only the tag number
-                choice = self.choices[tag & 0x1f]
-            elif self.flexible_tag:
+            if self.flexible_tag:
                 choice = ASN1F_field
             else:
                 raise ASN1_Error(
@@ -757,7 +753,7 @@ def i2m(self, pkt, x):
             s = raw(x)
             if hash(type(x)) in self.pktchoices:
                 imp, exp = self.pktchoices[hash(type(x))]
-                s = BER_tagging_enc(s, hidden_tag=self.ASN1_tag,
+                s = BER_tagging_enc(s,
                                     implicit_tag=imp,
                                     explicit_tag=exp)
         return BER_tagging_enc(s, explicit_tag=self.explicit_tag)
@@ -800,7 +796,7 @@ def __init__(self,
         )
         if implicit_tag is None and explicit_tag is None and cls is not None:
             if cls.ASN1_root.ASN1_tag == ASN1_Class_UNIVERSAL.SEQUENCE:
-                self.network_tag = 16 | 0x20
+                self.network_tag = 16 | 0x20  # 16 + CONSTRUCTED
         self.default = default
 
     def m2i(self, pkt, s):
@@ -845,7 +841,7 @@ def i2m(self,
             if not hasattr(x, "ASN1_root"):
                 # A normal Packet (!= ASN1)
                 return s
-        return BER_tagging_enc(s, hidden_tag=self.ASN1_tag,
+        return BER_tagging_enc(s,
                                implicit_tag=self.implicit_tag,
                                explicit_tag=self.explicit_tag)