#!/usr/bin/env python
# coding: utf-8
# PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
-# Copyright (C) 2017-2019 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2017-2020 Sergey Matveev <stargrave@stargrave.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
-# License along with this program. If not, see
-# <http://www.gnu.org/licenses/>.
+# License along with this program. If not, see <http://www.gnu.org/licenses/>.
"""Python ASN.1 DER/BER codec with abstract structures
This library allows you to marshal various structures in ASN.1 DER
ability to specify mapping between some OID and field that must be
decoded with specific specification.
+.. _defines:
+
defines kwarg
_____________
where ``decode_path`` is a tuple holding so-called decode path to the
exact :py:class:`pyderasn.ObjectIdentifier` field you want to apply
-``defines``, holding exactly the same value as accepted in its keyword
-argument.
+``defines``, holding exactly the same value as accepted in its
+:ref:`keyword argument <defines>`.
For example, again for CMS, you want to automatically decode
``SignedData`` and CMC's (:rfc:`5272`) ``PKIData`` and ``PKIResponse``
This option should be used only for skipping some decode errors, just
to see the decoded structure somehow.
+Base Obj
+--------
+.. autoclass:: pyderasn.Obj
+ :members:
+
Primitive types
---------------
.. autofunction:: pyderasn.tag_decode
.. autofunction:: pyderasn.tag_ctxp
.. autofunction:: pyderasn.tag_ctxc
-.. autoclass:: pyderasn.Obj
.. autoclass:: pyderasn.DecodeError
:members: __init__
.. autoclass:: pyderasn.NotEnoughData
def colored(what, *args, **kwargs):
return what
+__version__ = "5.5"
__all__ = (
"Any",
########################################################################
class AutoAddSlots(type):
- def __new__(mcs, name, bases, _dict):
+ def __new__(cls, name, bases, _dict):
_dict["__slots__"] = _dict.get("__slots__", ())
- return type.__new__(mcs, name, bases, _dict)
+ return type.__new__(cls, name, bases, _dict)
@add_metaclass(AutoAddSlots)
@property
def tlen(self):
+ """See :ref:`decoding`
+ """
return len(self.tag)
@property
def tlvlen(self):
+ """See :ref:`decoding`
+ """
return self.tlen + self.llen + self.vlen
def __str__(self): # pragma: no cover
raise NotImplementedError()
def encode(self):
+ """Encode the structure
+
+ :returns: DER representation
+ """
raw = self._encode()
if self._expl is None:
return raw
determine if tag satisfies the scheme)
:param _ctx_immutable: do we need to copy ``ctx`` before using it
:returns: (Obj, remaining data)
+
+ .. seealso:: :ref:`decoding`
"""
if ctx is None:
ctx = {}
tag_only=tag_only,
)
if tag_only:
- return
+ return None
obj, tail = result
else:
try:
tag_only=tag_only,
)
if tag_only: # pragma: no cover
- return
+ return None
obj, tail = result
eoc_expected, tail = tail[:EOC_LEN], tail[EOC_LEN:]
if eoc_expected.tobytes() != EOC:
tag_only=tag_only,
)
if tag_only: # pragma: no cover
- return
+ return None
obj, tail = result
if obj.tlvlen < l and not ctx.get("allow_expl_oob", False):
raise DecodeError(
@property
def expled(self):
+ """See :ref:`decoding`
+ """
return self._expl is not None
@property
def expl_tag(self):
+ """See :ref:`decoding`
+ """
return self._expl
@property
def expl_tlen(self):
+ """See :ref:`decoding`
+ """
return len(self._expl)
@property
def expl_llen(self):
+ """See :ref:`decoding`
+ """
if self.expl_lenindef:
return 1
return len(len_encode(self.tlvlen))
@property
def expl_offset(self):
+ """See :ref:`decoding`
+ """
return self.offset - self.expl_tlen - self.expl_llen
@property
def expl_vlen(self):
+ """See :ref:`decoding`
+ """
return self.tlvlen
@property
def expl_tlvlen(self):
+ """See :ref:`decoding`
+ """
return self.expl_tlen + self.expl_llen + self.expl_vlen
@property
def fulloffset(self):
+ """See :ref:`decoding`
+ """
return self.expl_offset if self.expled else self.offset
@property
def fulllen(self):
+ """See :ref:`decoding`
+ """
return self.expl_tlvlen if self.expled else self.tlvlen
def pps_lenindef(self, decode_path):
offset=offset,
)
if tag_only:
- return
+ return None
try:
l, _, v = len_decode(lv)
except DecodeError as err:
for name, value in iteritems(self.specs):
if value == self._value:
return name
+ return None
def __call__(
self,
offset=offset,
)
if tag_only:
- return
+ return None
try:
l, llen, v = len_decode(lv)
except DecodeError as err:
if not frozenset(value) <= SET01:
raise ValueError("B's coding contains unacceptable chars")
return self._bits2octets(value)
- elif value.endswith("'H"):
+ if value.endswith("'H"):
value = value[1:-2]
return (
len(value) * 4,
)
if isinstance(value, binary_type):
return (len(value) * 8, value)
- else:
- raise InvalidValueType((self.__class__, string_types, binary_type))
+ raise InvalidValueType((self.__class__, string_types, binary_type))
if isinstance(value, tuple):
if (
len(value) == 2 and
)
if t == self.tag:
if tag_only: # pragma: no cover
- return
+ return None
return self._decode_chunk(lv, offset, decode_path, ctx)
if t == self.tag_constructed:
if not ctx.get("bered", False):
offset=offset,
)
if tag_only: # pragma: no cover
- return
+ return None
lenindef = False
try:
l, llen, v = len_decode(lv)
)
if t == self.tag:
if tag_only:
- return
+ return None
return self._decode_chunk(lv, offset, decode_path, ctx)
if t == self.tag_constructed:
if not ctx.get("bered", False):
offset=offset,
)
if tag_only:
- return
+ return None
lenindef = False
try:
l, llen, v = len_decode(lv)
offset=offset,
)
if tag_only: # pragma: no cover
- return
+ return None
try:
l, _, v = len_decode(lv)
except DecodeError as err:
offset=offset,
)
if tag_only: # pragma: no cover
- return
+ return None
try:
l, llen, v = len_decode(lv)
except DecodeError as err:
offset=offset,
)
if tag_only: # pragma: no cover
- return
+ return None
value, tail = spec.decode(
tlv,
offset=offset,
if spec.optional:
continue
return False
- else:
- if not value.ready:
- return False
+ if not value.ready:
+ return False
return True
@property
offset=offset,
)
if tag_only: # pragma: no cover
- return
+ return None
lenindef = False
ctx_bered = ctx.get("bered", False)
try:
ctx=ctx,
_ctx_immutable=False,
)
- except TagMismatch:
- if spec.optional:
+ except TagMismatch as err:
+ if (len(err.decode_path) == len(decode_path) + 1) and spec.optional:
continue
raise
offset=offset,
)
if tag_only:
- return
+ return None
lenindef = False
ctx_bered = ctx.get("bered", False)
try:
offset=offset,
)
if tag_only:
- return
+ return None
lenindef = False
ctx_bered = ctx.get("bered", False)
try: