X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=pyderasn.py;h=9e94184cd2274311f8a445cea3acd8a1f698c237;hb=f4208ef738d16dc4b7a919106b7bc031179d6a16;hp=00defa5ab0e6926f7221e97de99e8b3a8043f60c;hpb=ac1628691fa68bcc61a0374b219ead802b94e17b;p=pyderasn.git

diff --git a/pyderasn.py b/pyderasn.py
index 00defa5..9e94184 100755
--- a/pyderasn.py
+++ b/pyderasn.py
@@ -162,9 +162,12 @@ All objects have ``ready`` boolean property, that tells if object is
 ready to be encoded. If that kind of action is performed on unready
 object, then :py:exc:`pyderasn.ObjNotReady` exception will be raised.
 
-All objects have ``copy()`` method, that returns their copy, that can be
+All objects are friendly to ``copy.copy()`` and copied objects can be
 safely mutated.
 
+Also all objects can be safely ``pickle``-d, but pay attention that
+pickling among different PyDERASN versions is prohibited.
+
 .. _decoding:
 
 Decoding
@@ -684,7 +687,7 @@ except ImportError:  # pragma: no cover
     def colored(what, *args, **kwargs):
         return what
 
-__version__ = "5.6"
+__version__ = "6.1"
 
 __all__ = (
     "Any",
@@ -1113,11 +1116,26 @@ class Obj(object):
         """
         return (self.llen + self.vlen) > 0
 
-    def copy(self):  # pragma: no cover
-        """Make a copy of object, safe to be mutated
+    def __getstate__(self):  # pragma: no cover
+        """Used for making safe to be mutable pickleable copies
         """
         raise NotImplementedError()
 
+    def __setstate__(self, state):
+        if state.version != __version__:
+            raise ValueError("data is pickled by different PyDERASN version")
+        self.tag = self.tag_default
+        self._value = None
+        self._expl = None
+        self.default = None
+        self.optional = False
+        self.offset = 0
+        self.llen = 0
+        self.vlen = 0
+        self.expl_lenindef = False
+        self.lenindef = False
+        self.ber_encoded = False
+
     @property
     def tlen(self):
         """See :ref:`decoding`
@@ -1161,6 +1179,11 @@ class Obj(object):
             return raw
         return b"".join((self._expl, len_encode(len(raw)), raw))
 
+    def hexencode(self):
+        """Do hexadecimal encoded :py:meth:`pyderasn.Obj.encode`
+        """
+        return hexenc(self.encode())
+
     def decode(
             self,
             data,
@@ -1181,7 +1204,8 @@ class Obj(object):
         :param tag_only: decode only the tag, without length and contents
                          (used only in Choice and Set structures, trying to
                          determine if tag satisfies the scheme)
-        :param _ctx_immutable: do we need to copy ``ctx`` before using it
+        :param _ctx_immutable: do we need to ``copy.copy()`` ``ctx``
+                               before using it?
         :returns: (Obj, remaining data)
 
         .. seealso:: :ref:`decoding`
@@ -1304,6 +1328,16 @@ class Obj(object):
             raise ExceedingData(len(tail))
         return obj
 
+    def hexdecode(self, data, *args, **kwargs):
+        """Do :py:meth:`pyderasn.Obj.decode` with hexadecimal decoded data
+        """
+        return self.decode(hexdec(data), *args, **kwargs)
+
+    def hexdecod(self, data, *args, **kwargs):
+        """Do :py:meth:`pyderasn.Obj.decod` with hexadecimal decoded data
+        """
+        return self.decod(hexdec(data), *args, **kwargs)
+
     @property
     def expled(self):
         """See :ref:`decoding`
@@ -1635,9 +1669,8 @@ def pprint(
     """Pretty print object
 
     :param Obj obj: object you want to pretty print
-    :param oid_maps: list of ``OID <-> humand readable string`` dictionary.
-                     When OID from it is met, then its humand readable form
-                     is printed
+    :param oid_maps: list of ``str(OID) <-> human readable string`` dictionary.
+                     Its human readable form is printed when OID is met
     :param big_blobs: if large binary objects are met (like OctetString
                       values), do we need to print them too, on separate
                       lines
@@ -1691,6 +1724,22 @@ def pprint(
 # ASN.1 primitive types
 ########################################################################
 
+BooleanState = namedtuple("BooleanState", (
+    "version",
+    "value",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class Boolean(Obj):
     """``BOOLEAN`` boolean type
 
@@ -1745,20 +1794,35 @@ class Boolean(Obj):
     def ready(self):
         return self._value is not None
 
-    def copy(self):
-        obj = self.__class__()
-        obj._value = self._value
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return BooleanState(
+            __version__,
+            self._value,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(Boolean, self).__setstate__(state)
+        self._value = state.value
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __nonzero__(self):
         self._assert_ready()
@@ -1901,6 +1965,25 @@ class Boolean(Obj):
             yield pp
 
 
+IntegerState = namedtuple("IntegerState", (
+    "version",
+    "specs",
+    "value",
+    "bound_min",
+    "bound_max",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class Integer(Obj):
     """``INTEGER`` integer type
 
@@ -2002,22 +2085,41 @@ class Integer(Obj):
     def ready(self):
         return self._value is not None
 
-    def copy(self):
-        obj = self.__class__(_specs=self.specs)
-        obj._value = self._value
-        obj._bound_min = self._bound_min
-        obj._bound_max = self._bound_max
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return IntegerState(
+            __version__,
+            self.specs,
+            self._value,
+            self._bound_min,
+            self._bound_max,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(Integer, self).__setstate__(state)
+        self.specs = state.specs
+        self._value = state.value
+        self._bound_min = state.bound_min
+        self._bound_max = state.bound_max
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __int__(self):
         self._assert_ready()
@@ -2233,6 +2335,23 @@ class Integer(Obj):
 
 
 SET01 = frozenset(("0", "1"))
+BitStringState = namedtuple("BitStringState", (
+    "version",
+    "specs",
+    "value",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+    "tag_constructed",
+    "defined",
+))
 
 
 class BitString(Obj):
@@ -2387,23 +2506,41 @@ class BitString(Obj):
     def ready(self):
         return self._value is not None
 
-    def copy(self):
-        obj = self.__class__(_specs=self.specs)
-        value = self._value
-        if value is not None:
-            value = (value[0], value[1])
-        obj._value = value
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return BitStringState(
+            __version__,
+            self.specs,
+            self._value,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+            self.tag_constructed,
+            self.defined,
+        )
+
+    def __setstate__(self, state):
+        super(BitString, self).__setstate__(state)
+        self.specs = state.specs
+        self._value = state.value
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
+        self.tag_constructed = state.tag_constructed
+        self.defined = state.defined
 
     def __iter__(self):
         self._assert_ready()
@@ -2708,6 +2845,26 @@ class BitString(Obj):
             yield pp
 
 
+OctetStringState = namedtuple("OctetStringState", (
+    "version",
+    "value",
+    "bound_min",
+    "bound_max",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+    "tag_constructed",
+    "defined",
+))
+
+
 class OctetString(Obj):
     """``OCTET STRING`` binary string type
 
@@ -2797,22 +2954,43 @@ class OctetString(Obj):
     def ready(self):
         return self._value is not None
 
-    def copy(self):
-        obj = self.__class__()
-        obj._value = self._value
-        obj._bound_min = self._bound_min
-        obj._bound_max = self._bound_max
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return OctetStringState(
+            __version__,
+            self._value,
+            self._bound_min,
+            self._bound_max,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+            self.tag_constructed,
+            self.defined,
+        )
+
+    def __setstate__(self, state):
+        super(OctetString, self).__setstate__(state)
+        self._value = state.value
+        self._bound_min = state.bound_min
+        self._bound_max = state.bound_max
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
+        self.tag_constructed = state.tag_constructed
+        self.defined = state.defined
 
     def __bytes__(self):
         self._assert_ready()
@@ -3057,6 +3235,21 @@ class OctetString(Obj):
             yield pp
 
 
+NullState = namedtuple("NullState", (
+    "version",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class Null(Obj):
     """``NULL`` null object
 
@@ -3089,19 +3282,33 @@ class Null(Obj):
     def ready(self):
         return True
 
-    def copy(self):
-        obj = self.__class__()
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return NullState(
+            __version__,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(Null, self).__setstate__(state)
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __eq__(self, their):
         if not issubclass(their.__class__, Null):
@@ -3196,6 +3403,30 @@ class Null(Obj):
             yield pp
 
 
+ObjectIdentifierState = namedtuple("ObjectIdentifierState", (
+    "version",
+    "value",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+    "defines",
+))
+
+
+def pureint(value):
+    i = int(value)
+    if (value[0] in "+- ") or (value[-1] == " "):
+        raise ValueError("non-pure integer")
+    return i
+
+
 class ObjectIdentifier(Obj):
     """``OBJECT IDENTIFIER`` OID type
 
@@ -3273,7 +3504,7 @@ class ObjectIdentifier(Obj):
             return value._value
         if isinstance(value, string_types):
             try:
-                value = tuple(int(arc) for arc in value.split("."))
+                value = tuple(pureint(arc) for arc in value.split("."))
             except ValueError:
                 raise InvalidOID("unacceptable arcs values")
         if isinstance(value, tuple):
@@ -3287,6 +3518,8 @@ class ObjectIdentifier(Obj):
                 pass
             else:
                 raise InvalidOID("unacceptable first arc value")
+            if not all(arc >= 0 for arc in value):
+                raise InvalidOID("negative arc value")
             return value
         raise InvalidValueType((self.__class__, str, tuple))
 
@@ -3294,21 +3527,37 @@ class ObjectIdentifier(Obj):
     def ready(self):
         return self._value is not None
 
-    def copy(self):
-        obj = self.__class__()
-        obj._value = self._value
-        obj.defines = self.defines
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return ObjectIdentifierState(
+            __version__,
+            self._value,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+            self.defines,
+        )
+
+    def __setstate__(self, state):
+        super(ObjectIdentifier, self).__setstate__(state)
+        self._value = state.value
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
+        self.defines = state.defines
 
     def __iter__(self):
         self._assert_ready()
@@ -3542,23 +3791,6 @@ class Enumerated(Integer):
             raise InvalidValueType((self.__class__, int, str))
         return value
 
-    def copy(self):
-        obj = self.__class__(_specs=self.specs)
-        obj._value = self._value
-        obj._bound_min = self._bound_min
-        obj._bound_max = self._bound_max
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
-
     def __call__(
             self,
             value=None,
@@ -3769,6 +4001,12 @@ class NumericString(AllowableCharsMixin, CommonString):
         return value
 
 
+PrintableStringState = namedtuple(
+    "PrintableStringState",
+    OctetStringState._fields + ("allowable_chars",),
+)
+
+
 class PrintableString(AllowableCharsMixin, CommonString):
     """Printable string
 
@@ -3776,6 +4014,10 @@ class PrintableString(AllowableCharsMixin, CommonString):
 
     >>> PrintableString().allowable_chars
     frozenset([' ', "'", ..., 'z'])
+    >>> obj = PrintableString("foo*bar", allow_asterisk=True)
+    PrintableString PrintableString foo*bar
+    >>> obj.allow_asterisk, obj.allow_ampersand
+    (True, False)
     """
     __slots__ = ()
     tag_default = tag_encode(19)
@@ -3811,16 +4053,33 @@ class PrintableString(AllowableCharsMixin, CommonString):
             value, bounds, impl, expl, default, optional, _decoded,
         )
 
+    @property
+    def allow_asterisk(self):
+        """Is asterisk character allowed?
+        """
+        return self._asterisk <= self._allowable_chars
+
+    @property
+    def allow_ampersand(self):
+        """Is ampersand character allowed?
+        """
+        return self._ampersand <= self._allowable_chars
+
     def _value_sanitize(self, value):
         value = super(PrintableString, self)._value_sanitize(value)
         if not frozenset(value) <= self._allowable_chars:
             raise DecodeError("non-printable value")
         return value
 
-    def copy(self):
-        obj = super(PrintableString, self).copy()
-        obj._allowable_chars = self._allowable_chars
-        return obj
+    def __getstate__(self):
+        return PrintableStringState(
+            *super(PrintableString, self).__getstate__(),
+            **{"allowable_chars": self._allowable_chars}
+        )
+
+    def __setstate__(self, state):
+        super(PrintableString, self).__setstate__(state)
+        self._allowable_chars = state.allowable_chars
 
     def __call__(
             self,
@@ -3841,8 +4100,8 @@ class PrintableString(AllowableCharsMixin, CommonString):
             expl=self._expl if expl is None else expl,
             default=self.default if default is None else default,
             optional=self.optional if optional is None else optional,
-            allow_asterisk=self._asterisk <= self._allowable_chars,
-            allow_ampersand=self._ampersand <= self._allowable_chars,
+            allow_asterisk=self.allow_asterisk,
+            allow_ampersand=self.allow_ampersand,
         )
 
 
@@ -3877,7 +4136,14 @@ LEN_YYYYMMDDHHMMSSDMZ = len("YYYYMMDDHHMMSSDMZ")
 LEN_YYYYMMDDHHMMSSZ = len("YYYYMMDDHHMMSSZ")
 
 
-class UTCTime(CommonString):
+class VisibleString(CommonString):
+    __slots__ = ()
+    tag_default = tag_encode(26)
+    encoding = "ascii"
+    asn1_type_name = "VisibleString"
+
+
+class UTCTime(VisibleString):
     """``UTCTime`` datetime type
 
     >>> t = UTCTime(datetime(2017, 9, 30, 22, 7, 50, 123))
@@ -4050,6 +4316,10 @@ class GeneralizedTime(UTCTime):
        Only microsecond fractions are supported.
        :py:exc:`pyderasn.DecodeError` will be raised during decoding of
        higher precision values.
+
+    .. warning::
+
+       Zero year is unsupported.
     """
     __slots__ = ()
     tag_default = tag_encode(24)
@@ -4058,7 +4328,7 @@ class GeneralizedTime(UTCTime):
     def _strptime(self, value):
         l = len(value)
         if l == LEN_YYYYMMDDHHMMSSZ:
-            # datetime.strptime's format: %y%m%d%H%M%SZ
+            # datetime.strptime's format: %Y%m%d%H%M%SZ
             if value[-1] != "Z":
                 raise ValueError("non UTC timezone")
             return datetime(
@@ -4128,13 +4398,6 @@ class GraphicString(CommonString):
     asn1_type_name = "GraphicString"
 
 
-class VisibleString(CommonString):
-    __slots__ = ()
-    tag_default = tag_encode(26)
-    encoding = "ascii"
-    asn1_type_name = "VisibleString"
-
-
 class ISO646String(VisibleString):
     __slots__ = ()
     asn1_type_name = "ISO646String"
@@ -4161,6 +4424,23 @@ class BMPString(CommonString):
     asn1_type_name = "BMPString"
 
 
+ChoiceState = namedtuple("ChoiceState", (
+    "version",
+    "specs",
+    "value",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class Choice(Obj):
     """``CHOICE`` special type
 
@@ -4234,7 +4514,7 @@ class Choice(Obj):
             default_obj._value = default_value
             self.default = default_obj
             if value is None:
-                self._value = default_obj.copy()._value
+                self._value = copy(default_obj._value)
 
     def _value_sanitize(self, value):
         if isinstance(value, tuple) and len(value) == 2:
@@ -4260,21 +4540,36 @@ class Choice(Obj):
             self._value[1].bered
         )
 
-    def copy(self):
-        obj = self.__class__(schema=self.specs)
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        value = self._value
-        if value is not None:
-            obj._value = (value[0], value[1].copy())
-        return obj
+    def __getstate__(self):
+        return ChoiceState(
+            __version__,
+            self.specs,
+            copy(self._value),
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(Choice, self).__setstate__(state)
+        self.specs = state.specs
+        self._value = state.value
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __eq__(self, their):
         if isinstance(their, tuple) and len(their) == 2:
@@ -4448,6 +4743,22 @@ class PrimitiveTypes(Choice):
     ))
 
 
+AnyState = namedtuple("AnyState", (
+    "version",
+    "value",
+    "tag",
+    "expl",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+    "defined",
+))
+
+
 class Any(Obj):
     """``ANY`` special type
 
@@ -4502,19 +4813,35 @@ class Any(Obj):
             return False
         return self.defined[1].bered
 
-    def copy(self):
-        obj = self.__class__()
-        obj._value = self._value
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        return obj
+    def __getstate__(self):
+        return AnyState(
+            __version__,
+            self._value,
+            self.tag,
+            self._expl,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+            self.defined,
+        )
+
+    def __setstate__(self, state):
+        super(Any, self).__setstate__(state)
+        self._value = state.value
+        self.tag = state.tag
+        self._expl = state.expl
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
+        self.defined = state.defined
 
     def __eq__(self, their):
         if isinstance(their, binary_type):
@@ -4694,6 +5021,23 @@ def abs_decode_path(decode_path, rel_path):
     return decode_path + rel_path
 
 
+SequenceState = namedtuple("SequenceState", (
+    "version",
+    "specs",
+    "value",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class Sequence(Obj):
     """``SEQUENCE`` structure type
 
@@ -4823,7 +5167,7 @@ class Sequence(Obj):
             default_obj._value = default_value
             self.default = default_obj
             if value is None:
-                self._value = default_obj.copy()._value
+                self._value = copy(default_obj._value)
 
     @property
     def ready(self):
@@ -4843,20 +5187,37 @@ class Sequence(Obj):
             return True
         return any(value.bered for value in itervalues(self._value))
 
-    def copy(self):
-        obj = self.__class__(schema=self.specs)
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        obj._value = {k: v.copy() for k, v in iteritems(self._value)}
-        return obj
+    def __getstate__(self):
+        return SequenceState(
+            __version__,
+            self.specs,
+            {k: copy(v) for k, v in iteritems(self._value)},
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(Sequence, self).__setstate__(state)
+        self.specs = state.specs
+        self._value = state.value
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __eq__(self, their):
         if not isinstance(their, self.__class__):
@@ -5323,6 +5684,25 @@ class Set(Sequence):
         return obj, tail
 
 
+SequenceOfState = namedtuple("SequenceOfState", (
+    "version",
+    "spec",
+    "value",
+    "bound_min",
+    "bound_max",
+    "tag",
+    "expl",
+    "default",
+    "optional",
+    "offset",
+    "llen",
+    "vlen",
+    "expl_lenindef",
+    "lenindef",
+    "ber_encoded",
+))
+
+
 class SequenceOf(Obj):
     """``SEQUENCE OF`` sequence type
 
@@ -5392,7 +5772,7 @@ class SequenceOf(Obj):
             default_obj._value = default_value
             self.default = default_obj
             if value is None:
-                self._value = default_obj.copy()._value
+                self._value = copy(default_obj._value)
 
     def _value_sanitize(self, value):
         if issubclass(value.__class__, SequenceOf):
@@ -5418,22 +5798,41 @@ class SequenceOf(Obj):
             return True
         return any(v.bered for v in self._value)
 
-    def copy(self):
-        obj = self.__class__(schema=self.spec)
-        obj._bound_min = self._bound_min
-        obj._bound_max = self._bound_max
-        obj.tag = self.tag
-        obj._expl = self._expl
-        obj.default = self.default
-        obj.optional = self.optional
-        obj.offset = self.offset
-        obj.llen = self.llen
-        obj.vlen = self.vlen
-        obj.expl_lenindef = self.expl_lenindef
-        obj.lenindef = self.lenindef
-        obj.ber_encoded = self.ber_encoded
-        obj._value = [v.copy() for v in self._value]
-        return obj
+    def __getstate__(self):
+        return SequenceOfState(
+            __version__,
+            self.spec,
+            [copy(v) for v in self._value],
+            self._bound_min,
+            self._bound_max,
+            self.tag,
+            self._expl,
+            self.default,
+            self.optional,
+            self.offset,
+            self.llen,
+            self.vlen,
+            self.expl_lenindef,
+            self.lenindef,
+            self.ber_encoded,
+        )
+
+    def __setstate__(self, state):
+        super(SequenceOf, self).__setstate__(state)
+        self.spec = state.spec
+        self._value = state.value
+        self._bound_min = state.bound_min
+        self._bound_max = state.bound_max
+        self.tag = state.tag
+        self._expl = state.expl
+        self.default = state.default
+        self.optional = state.optional
+        self.offset = state.offset
+        self.llen = state.llen
+        self.vlen = state.vlen
+        self.expl_lenindef = state.expl_lenindef
+        self.lenindef = state.lenindef
+        self.ber_encoded = state.ber_encoded
 
     def __eq__(self, their):
         if isinstance(their, self.__class__):