Respect NO_COLOR environment variable
[pyderasn.git] / pyderasn.py
1 #!/usr/bin/env python
2 # coding: utf-8
3 # PyDERASN -- Python ASN.1 DER codec with abstract structures
4 # Copyright (C) 2017-2018 Sergey Matveev <stargrave@stargrave.org>
5 #
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU Lesser General Public License as
8 # published by the Free Software Foundation, either version 3 of the
9 # License, or (at your option) any later version.
10 #
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this program.  If not, see
18 # <http://www.gnu.org/licenses/>.
19 """Python ASN.1 DER codec with abstract structures
20
21 This library allows you to marshal and unmarshal various structures in
22 ASN.1 DER format, like this:
23
24     >>> i = Integer(123)
25     >>> raw = i.encode()
26     >>> Integer().decode(raw) == i
27     True
28
29 There are primitive types, holding single values
30 (:py:class:`pyderasn.BitString`,
31 :py:class:`pyderasn.Boolean`,
32 :py:class:`pyderasn.Enumerated`,
33 :py:class:`pyderasn.GeneralizedTime`,
34 :py:class:`pyderasn.Integer`,
35 :py:class:`pyderasn.Null`,
36 :py:class:`pyderasn.ObjectIdentifier`,
37 :py:class:`pyderasn.OctetString`,
38 :py:class:`pyderasn.UTCTime`,
39 :py:class:`various strings <pyderasn.CommonString>`
40 (:py:class:`pyderasn.BMPString`,
41 :py:class:`pyderasn.GeneralString`,
42 :py:class:`pyderasn.GraphicString`,
43 :py:class:`pyderasn.IA5String`,
44 :py:class:`pyderasn.ISO646String`,
45 :py:class:`pyderasn.NumericString`,
46 :py:class:`pyderasn.PrintableString`,
47 :py:class:`pyderasn.T61String`,
48 :py:class:`pyderasn.TeletexString`,
49 :py:class:`pyderasn.UniversalString`,
50 :py:class:`pyderasn.UTF8String`,
51 :py:class:`pyderasn.VideotexString`,
52 :py:class:`pyderasn.VisibleString`)),
53 constructed types, holding multiple primitive types
54 (:py:class:`pyderasn.Sequence`,
55 :py:class:`pyderasn.SequenceOf`,
56 :py:class:`pyderasn.Set`,
57 :py:class:`pyderasn.SetOf`),
58 and special types like
59 :py:class:`pyderasn.Any` and
60 :py:class:`pyderasn.Choice`.
61
62 Common for most types
63 ---------------------
64
65 Tags
66 ____
67
68 Most types in ASN.1 has specific tag for them. ``Obj.tag_default`` is
69 the default tag used during coding process. You can override it with
70 either ``IMPLICIT`` (using ``impl`` keyword argument), or
71 ``EXPLICIT`` one (using ``expl`` keyword argument). Both arguments take
72 raw binary string, containing that tag. You can **not** set implicit and
73 explicit tags simultaneously.
74
75 There are :py:func:`pyderasn.tag_ctxp` and :py:func:`pyderasn.tag_ctxc`
76 functions, allowing you to easily create ``CONTEXT``
77 ``PRIMITIVE``/``CONSTRUCTED`` tags, by specifying only the required tag
78 number. Pay attention that explicit tags always have *constructed* tag
79 (``tag_ctxc``), but implicit tags for primitive types are primitive
80 (``tag_ctxp``).
81
82 ::
83
84     >>> Integer(impl=tag_ctxp(1))
85     [1] INTEGER
86     >>> Integer(expl=tag_ctxc(2))
87     [2] EXPLICIT INTEGER
88
89 Implicit tag is not explicitly shown.
90
91 Two objects of the same type, but with different implicit/explicit tags
92 are **not** equal.
93
94 You can get object's effective tag (either default or implicited) through
95 ``tag`` property. You can decode it using :py:func:`pyderasn.tag_decode`
96 function::
97
98     >>> tag_decode(tag_ctxc(123))
99     (128, 32, 123)
100     >>> klass, form, num = tag_decode(tag_ctxc(123))
101     >>> klass == TagClassContext
102     True
103     >>> form == TagFormConstructed
104     True
105
106 To determine if object has explicit tag, use ``expled`` boolean property
107 and ``expl_tag`` property, returning explicit tag's value.
108
109 Default/optional
110 ________________
111
112 Many objects in sequences could be ``OPTIONAL`` and could have
113 ``DEFAULT`` value. You can specify that object's property using
114 corresponding keyword arguments.
115
116     >>> Integer(optional=True, default=123)
117     INTEGER 123 OPTIONAL DEFAULT
118
119 Those specifications do not play any role in primitive value encoding,
120 but are taken into account when dealing with sequences holding them. For
121 example ``TBSCertificate`` sequence holds defaulted, explicitly tagged
122 ``version`` field::
123
124     class Version(Integer):
125         schema = (
126             ("v1", 0),
127             ("v2", 1),
128             ("v3", 2),
129         )
130     class TBSCertificate(Sequence):
131         schema = (
132             ("version", Version(expl=tag_ctxc(0), default="v1")),
133         [...]
134
135 When default argument is used and value is not specified, then it equals
136 to default one.
137
138 .. _bounds:
139
140 Size constraints
141 ________________
142
143 Some objects give ability to set value size constraints. This is either
144 possible integer value, or allowed length of various strings and
145 sequences. Constraints are set in the following way::
146
147     class X(...):
148         bounds = (MIN, MAX)
149
150 And values satisfaction is checked as: ``MIN <= X <= MAX``.
151
152 For simplicity you can also set bounds the following way::
153
154     bounded_x = X(bounds=(MIN, MAX))
155
156 If bounds are not satisfied, then :py:exc:`pyderasn.BoundsError` is
157 raised.
158
159 Common methods
160 ______________
161
162 All objects have ``ready`` boolean property, that tells if object is
163 ready to be encoded. If that kind of action is performed on unready
164 object, then :py:exc:`pyderasn.ObjNotReady` exception will be raised.
165
166 All objects have ``copy()`` method, that returns their copy, that can be
167 safely mutated.
168
169 .. _decoding:
170
171 Decoding
172 --------
173
174 Decoding is performed using ``decode()`` method. ``offset`` optional
175 argument could be used to set initial object's offset in the binary
176 data, for convenience. It returns decoded object and remaining
177 unmarshalled data (tail). Internally all work is done on
178 ``memoryview(data)``, and you can leave returning tail as a memoryview,
179 by specifying ``leavemm=True`` argument.
180
181 When object is decoded, ``decoded`` property is true and you can safely
182 use following properties:
183
184 * ``offset`` -- position including initial offset where object's tag starts
185 * ``tlen`` -- length of object's tag
186 * ``llen`` -- length of object's length value
187 * ``vlen`` -- length of object's value
188 * ``tlvlen`` -- length of the whole object
189
190 Pay attention that those values do **not** include anything related to
191 explicit tag. If you want to know information about it, then use:
192 ``expled`` (to know if explicit tag is set), ``expl_offset`` (it is
193 lesser than ``offset``), ``expl_tlen``, ``expl_llen``, ``expl_vlen``
194 (that actually equals to ordinary ``tlvlen``).
195
196 When error occurs, then :py:exc:`pyderasn.DecodeError` is raised.
197
198 .. _ctx:
199
200 Context
201 _______
202
203 You can specify so called context keyword argument during ``decode()``
204 invocation. It is dictionary containing various options governing
205 decoding process.
206
207 Currently available context options:
208
209 * :ref:`defines_by_path <defines_by_path_ctx>`
210 * :ref:`strict_default_existence <strict_default_existence_ctx>`
211
212 .. _pprinting:
213
214 Pretty printing
215 ---------------
216
217 All objects have ``pps()`` method, that is a generator of
218 :py:class:`pyderasn.PP` namedtuple, holding various raw information
219 about the object. If ``pps`` is called on sequences, then all underlying
220 ``PP`` will be yielded.
221
222 You can use :py:func:`pyderasn.pp_console_row` function, converting
223 those ``PP`` to human readable string. Actually exactly it is used for
224 all object ``repr``. But it is easy to write custom formatters.
225
226     >>> from pyderasn import pprint
227     >>> encoded = Integer(-12345).encode()
228     >>> obj, tail = Integer().decode(encoded)
229     >>> print(pprint(obj))
230         0   [1,1,   2] INTEGER -12345
231
232 .. _definedby:
233
234 DEFINED BY
235 ----------
236
237 ASN.1 structures often have ANY and OCTET STRING fields, that are
238 DEFINED BY some previously met ObjectIdentifier. This library provides
239 ability to specify mapping between some OID and field that must be
240 decoded with specific specification.
241
242 defines kwarg
243 _____________
244
245 :py:class:`pyderasn.ObjectIdentifier` field inside
246 :py:class:`pyderasn.Sequence` can hold mapping between OIDs and
247 necessary for decoding structures. For example, CMS (:rfc:`5652`)
248 container::
249
250     class ContentInfo(Sequence):
251         schema = (
252             ("contentType", ContentType(defines=((("content",), {
253                 id_digestedData: DigestedData(),
254                 id_signedData: SignedData(),
255             }),))),
256             ("content", Any(expl=tag_ctxc(0))),
257         )
258
259 ``contentType`` field tells that it defines that ``content`` must be
260 decoded with ``SignedData`` specification, if ``contentType`` equals to
261 ``id-signedData``. The same applies to ``DigestedData``. If
262 ``contentType`` contains unknown OID, then no automatic decoding is
263 done.
264
265 You can specify multiple fields, that will be autodecoded -- that is why
266 ``defines`` kwarg is a sequence. You can specify defined field
267 relatively or absolutely to current decode path. For example ``defines``
268 for AlgorithmIdentifier of X.509's
269 ``tbsCertificate.subjectPublicKeyInfo.algorithm.algorithm``::
270
271         (
272             (('parameters',), {
273                 id_ecPublicKey: ECParameters(),
274                 id_GostR3410_2001: GostR34102001PublicKeyParameters(),
275             }),
276             (('..', 'subjectPublicKey'), {
277                 id_rsaEncryption: RSAPublicKey(),
278                 id_GostR3410_2001: OctetString(),
279             }),
280         ),
281
282 tells that if certificate's SPKI algorithm is GOST R 34.10-2001, then
283 autodecode its parameters inside SPKI's algorithm and its public key
284 itself.
285
286 Following types can be automatically decoded (DEFINED BY):
287
288 * :py:class:`pyderasn.Any`
289 * :py:class:`pyderasn.BitString` (that is multiple of 8 bits)
290 * :py:class:`pyderasn.OctetString`
291 * :py:class:`pyderasn.SequenceOf`/:py:class:`pyderasn.SetOf`
292   ``Any``/``OctetString``-s
293
294 When any of those fields is automatically decoded, then ``.defined``
295 attribute contains ``(OID, value)`` tuple. ``OID`` tells by which OID it
296 was defined, ``value`` contains corresponding decoded value. For example
297 above, ``content_info["content"].defined == (id_signedData,
298 signed_data)``.
299
300 .. _defines_by_path_ctx:
301
302 defines_by_path context option
303 ______________________________
304
305 Sometimes you either can not or do not want to explicitly set *defines*
306 in the scheme. You can dynamically apply those definitions when calling
307 ``.decode()`` method.
308
309 Specify ``defines_by_path`` key in the :ref:`decode context <ctx>`. Its
310 value must be sequence of following tuples::
311
312     (decode_path, defines)
313
314 where ``decode_path`` is a tuple holding so-called decode path to the
315 exact :py:class:`pyderasn.ObjectIdentifier` field you want to apply
316 ``defines``, holding exactly the same value as accepted in its keyword
317 argument.
318
319 For example, again for CMS, you want to automatically decode
320 ``SignedData`` and CMC's (:rfc:`5272`) ``PKIData`` and ``PKIResponse``
321 structures it may hold. Also, automatically decode ``controlSequence``
322 of ``PKIResponse``::
323
324     content_info, tail = ContentInfo().decode(data, defines_by_path=(
325         (
326             ("contentType",),
327             ((("content",), {id_signedData: SignedData()}),),
328         ),
329         (
330             (
331                 "content",
332                 DecodePathDefBy(id_signedData),
333                 "encapContentInfo",
334                 "eContentType",
335             ),
336             ((("eContent",), {
337                 id_cct_PKIData: PKIData(),
338                 id_cct_PKIResponse: PKIResponse(),
339             })),
340         ),
341         (
342             (
343                 "content",
344                 DecodePathDefBy(id_signedData),
345                 "encapContentInfo",
346                 "eContent",
347                 DecodePathDefBy(id_cct_PKIResponse),
348                 "controlSequence",
349                 any,
350                 "attrType",
351             ),
352             ((("attrValues",), {
353                 id_cmc_recipientNonce: RecipientNonce(),
354                 id_cmc_senderNonce: SenderNonce(),
355                 id_cmc_statusInfoV2: CMCStatusInfoV2(),
356                 id_cmc_transactionId: TransactionId(),
357             })),
358         ),
359     ))
360
361 Pay attention for :py:class:`pyderasn.DecodePathDefBy` and ``any``.
362 First function is useful for path construction when some automatic
363 decoding is already done. ``any`` means literally any value it meet --
364 useful for SEQUENCE/SET OF-s.
365
366 Primitive types
367 ---------------
368
369 Boolean
370 _______
371 .. autoclass:: pyderasn.Boolean
372    :members: __init__
373
374 Integer
375 _______
376 .. autoclass:: pyderasn.Integer
377    :members: __init__
378
379 BitString
380 _________
381 .. autoclass:: pyderasn.BitString
382    :members: __init__
383
384 OctetString
385 ___________
386 .. autoclass:: pyderasn.OctetString
387    :members: __init__
388
389 Null
390 ____
391 .. autoclass:: pyderasn.Null
392    :members: __init__
393
394 ObjectIdentifier
395 ________________
396 .. autoclass:: pyderasn.ObjectIdentifier
397    :members: __init__
398
399 Enumerated
400 __________
401 .. autoclass:: pyderasn.Enumerated
402
403 CommonString
404 ____________
405 .. autoclass:: pyderasn.CommonString
406
407 UTCTime
408 _______
409 .. autoclass:: pyderasn.UTCTime
410    :members: __init__, todatetime
411
412 GeneralizedTime
413 _______________
414 .. autoclass:: pyderasn.GeneralizedTime
415
416 Special types
417 -------------
418
419 Choice
420 ______
421 .. autoclass:: pyderasn.Choice
422    :members: __init__
423
424 PrimitiveTypes
425 ______________
426 .. autoclass:: PrimitiveTypes
427
428 Any
429 ___
430 .. autoclass:: pyderasn.Any
431    :members: __init__
432
433 Constructed types
434 -----------------
435
436 Sequence
437 ________
438 .. autoclass:: pyderasn.Sequence
439    :members: __init__
440
441 Set
442 ___
443 .. autoclass:: pyderasn.Set
444    :members: __init__
445
446 SequenceOf
447 __________
448 .. autoclass:: pyderasn.SequenceOf
449    :members: __init__
450
451 SetOf
452 _____
453 .. autoclass:: pyderasn.SetOf
454    :members: __init__
455
456 Various
457 -------
458
459 .. autofunction:: pyderasn.abs_decode_path
460 .. autofunction:: pyderasn.hexenc
461 .. autofunction:: pyderasn.hexdec
462 .. autofunction:: pyderasn.tag_encode
463 .. autofunction:: pyderasn.tag_decode
464 .. autofunction:: pyderasn.tag_ctxp
465 .. autofunction:: pyderasn.tag_ctxc
466 .. autoclass:: pyderasn.Obj
467 """
468
469 from codecs import getdecoder
470 from codecs import getencoder
471 from collections import namedtuple
472 from collections import OrderedDict
473 from datetime import datetime
474 from math import ceil
475 from os import environ
476
477 from six import add_metaclass
478 from six import binary_type
479 from six import byte2int
480 from six import indexbytes
481 from six import int2byte
482 from six import integer_types
483 from six import iterbytes
484 from six import PY2
485 from six import string_types
486 from six import text_type
487 from six.moves import xrange as six_xrange
488
489
490 try:
491     from termcolor import colored
492 except ImportError:
493     def colored(what, *args):
494         return what
495
496
497 __all__ = (
498     "Any",
499     "BitString",
500     "BMPString",
501     "Boolean",
502     "BoundsError",
503     "Choice",
504     "DecodeError",
505     "DecodePathDefBy",
506     "Enumerated",
507     "GeneralizedTime",
508     "GeneralString",
509     "GraphicString",
510     "hexdec",
511     "hexenc",
512     "IA5String",
513     "Integer",
514     "InvalidLength",
515     "InvalidOID",
516     "InvalidValueType",
517     "ISO646String",
518     "NotEnoughData",
519     "Null",
520     "NumericString",
521     "obj_by_path",
522     "ObjectIdentifier",
523     "ObjNotReady",
524     "ObjUnknown",
525     "OctetString",
526     "PrimitiveTypes",
527     "PrintableString",
528     "Sequence",
529     "SequenceOf",
530     "Set",
531     "SetOf",
532     "T61String",
533     "tag_ctxc",
534     "tag_ctxp",
535     "tag_decode",
536     "TagClassApplication",
537     "TagClassContext",
538     "TagClassPrivate",
539     "TagClassUniversal",
540     "TagFormConstructed",
541     "TagFormPrimitive",
542     "TagMismatch",
543     "TeletexString",
544     "UniversalString",
545     "UTCTime",
546     "UTF8String",
547     "VideotexString",
548     "VisibleString",
549 )
550
551 TagClassUniversal = 0
552 TagClassApplication = 1 << 6
553 TagClassContext = 1 << 7
554 TagClassPrivate = 1 << 6 | 1 << 7
555 TagFormPrimitive = 0
556 TagFormConstructed = 1 << 5
557 TagClassReprs = {
558     TagClassContext: "",
559     TagClassApplication: "APPLICATION ",
560     TagClassPrivate: "PRIVATE ",
561     TagClassUniversal: "UNIV ",
562 }
563
564
565 ########################################################################
566 # Errors
567 ########################################################################
568
569 class DecodeError(Exception):
570     def __init__(self, msg="", klass=None, decode_path=(), offset=0):
571         """
572         :param str msg: reason of decode failing
573         :param klass: optional exact DecodeError inherited class (like
574                       :py:exc:`NotEnoughData`, :py:exc:`TagMismatch`,
575                       :py:exc:`InvalidLength`)
576         :param decode_path: tuple of strings. It contains human
577                             readable names of the fields through which
578                             decoding process has passed
579         :param int offset: binary offset where failure happened
580         """
581         super(DecodeError, self).__init__()
582         self.msg = msg
583         self.klass = klass
584         self.decode_path = decode_path
585         self.offset = offset
586
587     def __str__(self):
588         return " ".join(
589             c for c in (
590                 "" if self.klass is None else self.klass.__name__,
591                 (
592                     ("(%s)" % ".".join(str(dp) for dp in self.decode_path))
593                     if len(self.decode_path) > 0 else ""
594                 ),
595                 ("(at %d)" % self.offset) if self.offset > 0 else "",
596                 self.msg,
597             ) if c != ""
598         )
599
600     def __repr__(self):
601         return "%s(%s)" % (self.__class__.__name__, self)
602
603
604 class NotEnoughData(DecodeError):
605     pass
606
607
608 class TagMismatch(DecodeError):
609     pass
610
611
612 class InvalidLength(DecodeError):
613     pass
614
615
616 class InvalidOID(DecodeError):
617     pass
618
619
620 class ObjUnknown(ValueError):
621     def __init__(self, name):
622         super(ObjUnknown, self).__init__()
623         self.name = name
624
625     def __str__(self):
626         return "object is unknown: %s" % self.name
627
628     def __repr__(self):
629         return "%s(%s)" % (self.__class__.__name__, self)
630
631
632 class ObjNotReady(ValueError):
633     def __init__(self, name):
634         super(ObjNotReady, self).__init__()
635         self.name = name
636
637     def __str__(self):
638         return "object is not ready: %s" % self.name
639
640     def __repr__(self):
641         return "%s(%s)" % (self.__class__.__name__, self)
642
643
644 class InvalidValueType(ValueError):
645     def __init__(self, expected_types):
646         super(InvalidValueType, self).__init__()
647         self.expected_types = expected_types
648
649     def __str__(self):
650         return "invalid value type, expected: %s" % ", ".join(
651             [repr(t) for t in self.expected_types]
652         )
653
654     def __repr__(self):
655         return "%s(%s)" % (self.__class__.__name__, self)
656
657
658 class BoundsError(ValueError):
659     def __init__(self, bound_min, value, bound_max):
660         super(BoundsError, self).__init__()
661         self.bound_min = bound_min
662         self.value = value
663         self.bound_max = bound_max
664
665     def __str__(self):
666         return "unsatisfied bounds: %s <= %s <= %s" % (
667             self.bound_min,
668             self.value,
669             self.bound_max,
670         )
671
672     def __repr__(self):
673         return "%s(%s)" % (self.__class__.__name__, self)
674
675
676 ########################################################################
677 # Basic coders
678 ########################################################################
679
680 _hexdecoder = getdecoder("hex")
681 _hexencoder = getencoder("hex")
682
683
684 def hexdec(data):
685     """Binary data to hexadecimal string convert
686     """
687     return _hexdecoder(data)[0]
688
689
690 def hexenc(data):
691     """Hexadecimal string to binary data convert
692     """
693     return _hexencoder(data)[0].decode("ascii")
694
695
696 def int_bytes_len(num, byte_len=8):
697     if num == 0:
698         return 1
699     return int(ceil(float(num.bit_length()) / byte_len))
700
701
702 def zero_ended_encode(num):
703     octets = bytearray(int_bytes_len(num, 7))
704     i = len(octets) - 1
705     octets[i] = num & 0x7F
706     num >>= 7
707     i -= 1
708     while num > 0:
709         octets[i] = 0x80 | (num & 0x7F)
710         num >>= 7
711         i -= 1
712     return bytes(octets)
713
714
715 def tag_encode(num, klass=TagClassUniversal, form=TagFormPrimitive):
716     """Encode tag to binary form
717
718     :param int num: tag's number
719     :param int klass: tag's class (:py:data:`pyderasn.TagClassUniversal`,
720                       :py:data:`pyderasn.TagClassContext`,
721                       :py:data:`pyderasn.TagClassApplication`,
722                       :py:data:`pyderasn.TagClassPrivate`)
723     :param int form: tag's form (:py:data:`pyderasn.TagFormPrimitive`,
724                      :py:data:`pyderasn.TagFormConstructed`)
725     """
726     if num < 31:
727         # [XX|X|.....]
728         return int2byte(klass | form | num)
729     # [XX|X|11111][1.......][1.......] ... [0.......]
730     return int2byte(klass | form | 31) + zero_ended_encode(num)
731
732
733 def tag_decode(tag):
734     """Decode tag from binary form
735
736     .. warning::
737
738        No validation is performed, assuming that it has already passed.
739
740     It returns tuple with three integers, as
741     :py:func:`pyderasn.tag_encode` accepts.
742     """
743     first_octet = byte2int(tag)
744     klass = first_octet & 0xC0
745     form = first_octet & 0x20
746     if first_octet & 0x1F < 0x1F:
747         return (klass, form, first_octet & 0x1F)
748     num = 0
749     for octet in iterbytes(tag[1:]):
750         num <<= 7
751         num |= octet & 0x7F
752     return (klass, form, num)
753
754
755 def tag_ctxp(num):
756     """Create CONTEXT PRIMITIVE tag
757     """
758     return tag_encode(num=num, klass=TagClassContext, form=TagFormPrimitive)
759
760
761 def tag_ctxc(num):
762     """Create CONTEXT CONSTRUCTED tag
763     """
764     return tag_encode(num=num, klass=TagClassContext, form=TagFormConstructed)
765
766
767 def tag_strip(data):
768     """Take off tag from the data
769
770     :returns: (encoded tag, tag length, remaining data)
771     """
772     if len(data) == 0:
773         raise NotEnoughData("no data at all")
774     if byte2int(data) & 0x1F < 31:
775         return data[:1], 1, data[1:]
776     i = 0
777     while True:
778         i += 1
779         if i == len(data):
780             raise DecodeError("unfinished tag")
781         if indexbytes(data, i) & 0x80 == 0:
782             break
783     i += 1
784     return data[:i], i, data[i:]
785
786
787 def len_encode(l):
788     if l < 0x80:
789         return int2byte(l)
790     octets = bytearray(int_bytes_len(l) + 1)
791     octets[0] = 0x80 | (len(octets) - 1)
792     for i in six_xrange(len(octets) - 1, 0, -1):
793         octets[i] = l & 0xFF
794         l >>= 8
795     return bytes(octets)
796
797
798 def len_decode(data):
799     if len(data) == 0:
800         raise NotEnoughData("no data at all")
801     first_octet = byte2int(data)
802     if first_octet & 0x80 == 0:
803         return first_octet, 1, data[1:]
804     octets_num = first_octet & 0x7F
805     if octets_num + 1 > len(data):
806         raise NotEnoughData("encoded length is longer than data")
807     if octets_num == 0:
808         raise DecodeError("long form instead of short one")
809     if byte2int(data[1:]) == 0:
810         raise DecodeError("leading zeros")
811     l = 0
812     for v in iterbytes(data[1:1 + octets_num]):
813         l = (l << 8) | v
814     if l <= 127:
815         raise DecodeError("long form instead of short one")
816     return l, 1 + octets_num, data[1 + octets_num:]
817
818
819 ########################################################################
820 # Base class
821 ########################################################################
822
823 class AutoAddSlots(type):
824     def __new__(mcs, name, bases, _dict):
825         _dict["__slots__"] = _dict.get("__slots__", ())
826         return type.__new__(mcs, name, bases, _dict)
827
828
829 @add_metaclass(AutoAddSlots)
830 class Obj(object):
831     """Common ASN.1 object class
832
833     All ASN.1 types are inherited from it. It has metaclass that
834     automatically adds ``__slots__`` to all inherited classes.
835     """
836     __slots__ = (
837         "tag",
838         "_value",
839         "_expl",
840         "default",
841         "optional",
842         "offset",
843         "llen",
844         "vlen",
845     )
846
847     def __init__(
848             self,
849             impl=None,
850             expl=None,
851             default=None,
852             optional=False,
853             _decoded=(0, 0, 0),
854     ):
855         self.tag = getattr(self, "impl", self.tag_default) if impl is None else impl
856         self._expl = getattr(self, "expl", None) if expl is None else expl
857         if self.tag != self.tag_default and self._expl is not None:
858             raise ValueError(
859                 "implicit and explicit tags can not be set simultaneously"
860             )
861         if default is not None:
862             optional = True
863         self.optional = optional
864         self.offset, self.llen, self.vlen = _decoded
865         self.default = None
866
867     @property
868     def ready(self):  # pragma: no cover
869         """Is object ready to be encoded?
870         """
871         raise NotImplementedError()
872
873     def _assert_ready(self):
874         if not self.ready:
875             raise ObjNotReady(self.__class__.__name__)
876
877     @property
878     def decoded(self):
879         """Is object decoded?
880         """
881         return (self.llen + self.vlen) > 0
882
883     def copy(self):  # pragma: no cover
884         """Make a copy of object, safe to be mutated
885         """
886         raise NotImplementedError()
887
888     @property
889     def tlen(self):
890         return len(self.tag)
891
892     @property
893     def tlvlen(self):
894         return self.tlen + self.llen + self.vlen
895
896     def __str__(self):  # pragma: no cover
897         return self.__bytes__() if PY2 else self.__unicode__()
898
899     def __ne__(self, their):
900         return not(self == their)
901
902     def __gt__(self, their):  # pragma: no cover
903         return not(self < their)
904
905     def __le__(self, their):  # pragma: no cover
906         return (self == their) or (self < their)
907
908     def __ge__(self, their):  # pragma: no cover
909         return (self == their) or (self > their)
910
911     def _encode(self):  # pragma: no cover
912         raise NotImplementedError()
913
914     def _decode(self, tlv, offset, decode_path, ctx):  # pragma: no cover
915         raise NotImplementedError()
916
917     def encode(self):
918         raw = self._encode()
919         if self._expl is None:
920             return raw
921         return b"".join((self._expl, len_encode(len(raw)), raw))
922
923     def decode(self, data, offset=0, leavemm=False, decode_path=(), ctx=None):
924         """Decode the data
925
926         :param data: either binary or memoryview
927         :param int offset: initial data's offset
928         :param bool leavemm: do we need to leave memoryview of remaining
929                     data as is, or convert it to bytes otherwise
930         :param ctx: optional :ref:`context <ctx>` governing decoding process.
931         :returns: (Obj, remaining data)
932         """
933         if ctx is None:
934             ctx = {}
935         tlv = memoryview(data)
936         if self._expl is None:
937             obj, tail = self._decode(
938                 tlv,
939                 offset,
940                 decode_path=decode_path,
941                 ctx=ctx,
942             )
943         else:
944             try:
945                 t, tlen, lv = tag_strip(tlv)
946             except DecodeError as err:
947                 raise err.__class__(
948                     msg=err.msg,
949                     klass=self.__class__,
950                     decode_path=decode_path,
951                     offset=offset,
952                 )
953             if t != self._expl:
954                 raise TagMismatch(
955                     klass=self.__class__,
956                     decode_path=decode_path,
957                     offset=offset,
958                 )
959             try:
960                 l, llen, v = len_decode(lv)
961             except DecodeError as err:
962                 raise err.__class__(
963                     msg=err.msg,
964                     klass=self.__class__,
965                     decode_path=decode_path,
966                     offset=offset,
967                 )
968             if l > len(v):
969                 raise NotEnoughData(
970                     "encoded length is longer than data",
971                     klass=self.__class__,
972                     decode_path=decode_path,
973                     offset=offset,
974                 )
975             obj, tail = self._decode(
976                 v,
977                 offset=offset + tlen + llen,
978                 decode_path=decode_path,
979                 ctx=ctx,
980             )
981         return obj, (tail if leavemm else tail.tobytes())
982
983     @property
984     def expled(self):
985         return self._expl is not None
986
987     @property
988     def expl_tag(self):
989         return self._expl
990
991     @property
992     def expl_tlen(self):
993         return len(self._expl)
994
995     @property
996     def expl_llen(self):
997         return len(len_encode(self.tlvlen))
998
999     @property
1000     def expl_offset(self):
1001         return self.offset - self.expl_tlen - self.expl_llen
1002
1003     @property
1004     def expl_vlen(self):
1005         return self.tlvlen
1006
1007     @property
1008     def expl_tlvlen(self):
1009         return self.expl_tlen + self.expl_llen + self.expl_vlen
1010
1011
1012 class DecodePathDefBy(object):
1013     """DEFINED BY representation inside decode path
1014     """
1015     __slots__ = ('defined_by',)
1016
1017     def __init__(self, defined_by):
1018         self.defined_by = defined_by
1019
1020     def __eq__(self, their):
1021         if not isinstance(their, self.__class__):
1022             return False
1023         return self.defined_by == their.defined_by
1024
1025     def __str__(self):
1026         return "DEFINED BY " + str(self.defined_by)
1027
1028     def __repr__(self):
1029         return "<%s: %s>" % (self.__class__.__name__, self.defined_by)
1030
1031
1032 ########################################################################
1033 # Pretty printing
1034 ########################################################################
1035
1036 PP = namedtuple("PP", (
1037     "asn1_type_name",
1038     "obj_name",
1039     "decode_path",
1040     "value",
1041     "blob",
1042     "optional",
1043     "default",
1044     "impl",
1045     "expl",
1046     "offset",
1047     "tlen",
1048     "llen",
1049     "vlen",
1050     "expl_offset",
1051     "expl_tlen",
1052     "expl_llen",
1053     "expl_vlen",
1054 ))
1055
1056
1057 def _pp(
1058         asn1_type_name="unknown",
1059         obj_name="unknown",
1060         decode_path=(),
1061         value=None,
1062         blob=None,
1063         optional=False,
1064         default=False,
1065         impl=None,
1066         expl=None,
1067         offset=0,
1068         tlen=0,
1069         llen=0,
1070         vlen=0,
1071         expl_offset=None,
1072         expl_tlen=None,
1073         expl_llen=None,
1074         expl_vlen=None,
1075 ):
1076     return PP(
1077         asn1_type_name,
1078         obj_name,
1079         decode_path,
1080         value,
1081         blob,
1082         optional,
1083         default,
1084         impl,
1085         expl,
1086         offset,
1087         tlen,
1088         llen,
1089         vlen,
1090         expl_offset,
1091         expl_tlen,
1092         expl_llen,
1093         expl_vlen,
1094     )
1095
1096
1097 def _colorize(what, colour, with_colours, attrs=("bold",)):
1098     return colored(what, colour, attrs=attrs) if with_colours else what
1099
1100
1101 def pp_console_row(
1102         pp,
1103         oids=None,
1104         with_offsets=False,
1105         with_blob=True,
1106         with_colours=False,
1107 ):
1108     cols = []
1109     if with_offsets:
1110         col = "%5d%s" % (
1111             pp.offset,
1112             (
1113                 "  " if pp.expl_offset is None else
1114                 ("-%d" % (pp.offset - pp.expl_offset))
1115             ),
1116         )
1117         cols.append(_colorize(col, "red", with_colours, ()))
1118         col = "[%d,%d,%4d]" % (pp.tlen, pp.llen, pp.vlen)
1119         cols.append(_colorize(col, "green", with_colours, ()))
1120     if len(pp.decode_path) > 0:
1121         cols.append(" ." * (len(pp.decode_path)))
1122         ent = pp.decode_path[-1]
1123         if isinstance(ent, DecodePathDefBy):
1124             cols.append(_colorize("DEFINED BY", "red", with_colours, ("reverse",)))
1125             value = str(ent.defined_by)
1126             if (
1127                     oids is not None and
1128                     ent.defined_by.asn1_type_name ==
1129                     ObjectIdentifier.asn1_type_name and
1130                     value in oids
1131             ):
1132                 cols.append(_colorize("%s:" % oids[value], "green", with_colours))
1133             else:
1134                 cols.append(_colorize("%s:" % value, "white", with_colours))
1135         else:
1136             cols.append(_colorize("%s:" % ent, "yellow", with_colours))
1137     if pp.expl is not None:
1138         klass, _, num = pp.expl
1139         col = "[%s%d] EXPLICIT" % (TagClassReprs[klass], num)
1140         cols.append(_colorize(col, "blue", with_colours))
1141     if pp.impl is not None:
1142         klass, _, num = pp.impl
1143         col = "[%s%d]" % (TagClassReprs[klass], num)
1144         cols.append(_colorize(col, "blue", with_colours))
1145     if pp.asn1_type_name.replace(" ", "") != pp.obj_name.upper():
1146         cols.append(_colorize(pp.obj_name, "magenta", with_colours))
1147     cols.append(_colorize(pp.asn1_type_name, "cyan", with_colours))
1148     if pp.value is not None:
1149         value = pp.value
1150         cols.append(_colorize(value, "white", with_colours))
1151         if (
1152                 oids is not None and
1153                 pp.asn1_type_name == ObjectIdentifier.asn1_type_name and
1154                 value in oids
1155         ):
1156             cols.append(_colorize("(%s)" % oids[value], "green", with_colours))
1157     if with_blob:
1158         if isinstance(pp.blob, binary_type):
1159             cols.append(hexenc(pp.blob))
1160         elif isinstance(pp.blob, tuple):
1161             cols.append(", ".join(pp.blob))
1162     if pp.optional:
1163         cols.append(_colorize("OPTIONAL", "red", with_colours))
1164     if pp.default:
1165         cols.append(_colorize("DEFAULT", "red", with_colours))
1166     return " ".join(cols)
1167
1168
1169 def pp_console_blob(pp):
1170     cols = [" " * len("XXXXXYY [X,X,XXXX]")]
1171     if len(pp.decode_path) > 0:
1172         cols.append(" ." * (len(pp.decode_path) + 1))
1173     if isinstance(pp.blob, binary_type):
1174         blob = hexenc(pp.blob).upper()
1175         for i in range(0, len(blob), 32):
1176             chunk = blob[i:i + 32]
1177             yield " ".join(cols + [":".join(
1178                 chunk[j:j + 2] for j in range(0, len(chunk), 2)
1179             )])
1180     elif isinstance(pp.blob, tuple):
1181         yield " ".join(cols + [", ".join(pp.blob)])
1182
1183
1184 def pprint(obj, oids=None, big_blobs=False, with_colours=False):
1185     """Pretty print object
1186
1187     :param Obj obj: object you want to pretty print
1188     :param oids: ``OID <-> humand readable string`` dictionary. When OID
1189                  from it is met, then its humand readable form is printed
1190     :param big_blobs: if large binary objects are met (like OctetString
1191                       values), do we need to print them too, on separate
1192                       lines
1193     :param with_colours: colourize output, if ``termcolor`` library
1194                          is available
1195     """
1196     def _pprint_pps(pps):
1197         for pp in pps:
1198             if hasattr(pp, "_fields"):
1199                 if big_blobs:
1200                     yield pp_console_row(
1201                         pp,
1202                         oids=oids,
1203                         with_offsets=True,
1204                         with_blob=False,
1205                         with_colours=with_colours,
1206                     )
1207                     for row in pp_console_blob(pp):
1208                         yield row
1209                 else:
1210                     yield pp_console_row(
1211                         pp,
1212                         oids=oids,
1213                         with_offsets=True,
1214                         with_blob=True,
1215                         with_colours=with_colours,
1216                     )
1217             else:
1218                 for row in _pprint_pps(pp):
1219                     yield row
1220     return "\n".join(_pprint_pps(obj.pps()))
1221
1222
1223 ########################################################################
1224 # ASN.1 primitive types
1225 ########################################################################
1226
1227 class Boolean(Obj):
1228     """``BOOLEAN`` boolean type
1229
1230     >>> b = Boolean(True)
1231     BOOLEAN True
1232     >>> b == Boolean(True)
1233     True
1234     >>> bool(b)
1235     True
1236     """
1237     __slots__ = ()
1238     tag_default = tag_encode(1)
1239     asn1_type_name = "BOOLEAN"
1240
1241     def __init__(
1242             self,
1243             value=None,
1244             impl=None,
1245             expl=None,
1246             default=None,
1247             optional=False,
1248             _decoded=(0, 0, 0),
1249     ):
1250         """
1251         :param value: set the value. Either boolean type, or
1252                       :py:class:`pyderasn.Boolean` object
1253         :param bytes impl: override default tag with ``IMPLICIT`` one
1254         :param bytes expl: override default tag with ``EXPLICIT`` one
1255         :param default: set default value. Type same as in ``value``
1256         :param bool optional: is object ``OPTIONAL`` in sequence
1257         """
1258         super(Boolean, self).__init__(impl, expl, default, optional, _decoded)
1259         self._value = None if value is None else self._value_sanitize(value)
1260         if default is not None:
1261             default = self._value_sanitize(default)
1262             self.default = self.__class__(
1263                 value=default,
1264                 impl=self.tag,
1265                 expl=self._expl,
1266             )
1267             if value is None:
1268                 self._value = default
1269
1270     def _value_sanitize(self, value):
1271         if issubclass(value.__class__, Boolean):
1272             return value._value
1273         if isinstance(value, bool):
1274             return value
1275         raise InvalidValueType((self.__class__, bool))
1276
1277     @property
1278     def ready(self):
1279         return self._value is not None
1280
1281     def copy(self):
1282         obj = self.__class__()
1283         obj._value = self._value
1284         obj.tag = self.tag
1285         obj._expl = self._expl
1286         obj.default = self.default
1287         obj.optional = self.optional
1288         obj.offset = self.offset
1289         obj.llen = self.llen
1290         obj.vlen = self.vlen
1291         return obj
1292
1293     def __nonzero__(self):
1294         self._assert_ready()
1295         return self._value
1296
1297     def __bool__(self):
1298         self._assert_ready()
1299         return self._value
1300
1301     def __eq__(self, their):
1302         if isinstance(their, bool):
1303             return self._value == their
1304         if not issubclass(their.__class__, Boolean):
1305             return False
1306         return (
1307             self._value == their._value and
1308             self.tag == their.tag and
1309             self._expl == their._expl
1310         )
1311
1312     def __call__(
1313             self,
1314             value=None,
1315             impl=None,
1316             expl=None,
1317             default=None,
1318             optional=None,
1319     ):
1320         return self.__class__(
1321             value=value,
1322             impl=self.tag if impl is None else impl,
1323             expl=self._expl if expl is None else expl,
1324             default=self.default if default is None else default,
1325             optional=self.optional if optional is None else optional,
1326         )
1327
1328     def _encode(self):
1329         self._assert_ready()
1330         return b"".join((
1331             self.tag,
1332             len_encode(1),
1333             (b"\xFF" if self._value else b"\x00"),
1334         ))
1335
1336     def _decode(self, tlv, offset, decode_path, ctx):
1337         try:
1338             t, _, lv = tag_strip(tlv)
1339         except DecodeError as err:
1340             raise err.__class__(
1341                 msg=err.msg,
1342                 klass=self.__class__,
1343                 decode_path=decode_path,
1344                 offset=offset,
1345             )
1346         if t != self.tag:
1347             raise TagMismatch(
1348                 klass=self.__class__,
1349                 decode_path=decode_path,
1350                 offset=offset,
1351             )
1352         try:
1353             l, _, v = len_decode(lv)
1354         except DecodeError as err:
1355             raise err.__class__(
1356                 msg=err.msg,
1357                 klass=self.__class__,
1358                 decode_path=decode_path,
1359                 offset=offset,
1360             )
1361         if l != 1:
1362             raise InvalidLength(
1363                 "Boolean's length must be equal to 1",
1364                 klass=self.__class__,
1365                 decode_path=decode_path,
1366                 offset=offset,
1367             )
1368         if l > len(v):
1369             raise NotEnoughData(
1370                 "encoded length is longer than data",
1371                 klass=self.__class__,
1372                 decode_path=decode_path,
1373                 offset=offset,
1374             )
1375         first_octet = byte2int(v)
1376         if first_octet == 0:
1377             value = False
1378         elif first_octet == 0xFF:
1379             value = True
1380         else:
1381             raise DecodeError(
1382                 "unacceptable Boolean value",
1383                 klass=self.__class__,
1384                 decode_path=decode_path,
1385                 offset=offset,
1386             )
1387         obj = self.__class__(
1388             value=value,
1389             impl=self.tag,
1390             expl=self._expl,
1391             default=self.default,
1392             optional=self.optional,
1393             _decoded=(offset, 1, 1),
1394         )
1395         return obj, v[1:]
1396
1397     def __repr__(self):
1398         return pp_console_row(next(self.pps()))
1399
1400     def pps(self, decode_path=()):
1401         yield _pp(
1402             asn1_type_name=self.asn1_type_name,
1403             obj_name=self.__class__.__name__,
1404             decode_path=decode_path,
1405             value=str(self._value) if self.ready else None,
1406             optional=self.optional,
1407             default=self == self.default,
1408             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
1409             expl=None if self._expl is None else tag_decode(self._expl),
1410             offset=self.offset,
1411             tlen=self.tlen,
1412             llen=self.llen,
1413             vlen=self.vlen,
1414             expl_offset=self.expl_offset if self.expled else None,
1415             expl_tlen=self.expl_tlen if self.expled else None,
1416             expl_llen=self.expl_llen if self.expled else None,
1417             expl_vlen=self.expl_vlen if self.expled else None,
1418         )
1419
1420
1421 class Integer(Obj):
1422     """``INTEGER`` integer type
1423
1424     >>> b = Integer(-123)
1425     INTEGER -123
1426     >>> b == Integer(-123)
1427     True
1428     >>> int(b)
1429     -123
1430
1431     >>> Integer(2, bounds=(1, 3))
1432     INTEGER 2
1433     >>> Integer(5, bounds=(1, 3))
1434     Traceback (most recent call last):
1435     pyderasn.BoundsError: unsatisfied bounds: 1 <= 5 <= 3
1436
1437     ::
1438
1439         class Version(Integer):
1440             schema = (
1441                 ("v1", 0),
1442                 ("v2", 1),
1443                 ("v3", 2),
1444             )
1445
1446     >>> v = Version("v1")
1447     Version INTEGER v1
1448     >>> int(v)
1449     0
1450     >>> v.named
1451     'v1'
1452     >>> v.specs
1453     {'v3': 2, 'v1': 0, 'v2': 1}
1454     """
1455     __slots__ = ("specs", "_bound_min", "_bound_max")
1456     tag_default = tag_encode(2)
1457     asn1_type_name = "INTEGER"
1458
1459     def __init__(
1460             self,
1461             value=None,
1462             bounds=None,
1463             impl=None,
1464             expl=None,
1465             default=None,
1466             optional=False,
1467             _specs=None,
1468             _decoded=(0, 0, 0),
1469     ):
1470         """
1471         :param value: set the value. Either integer type, named value
1472                       (if ``schema`` is specified in the class), or
1473                       :py:class:`pyderasn.Integer` object
1474         :param bounds: set ``(MIN, MAX)`` value constraint.
1475                        (-inf, +inf) by default
1476         :param bytes impl: override default tag with ``IMPLICIT`` one
1477         :param bytes expl: override default tag with ``EXPLICIT`` one
1478         :param default: set default value. Type same as in ``value``
1479         :param bool optional: is object ``OPTIONAL`` in sequence
1480         """
1481         super(Integer, self).__init__(impl, expl, default, optional, _decoded)
1482         self._value = value
1483         specs = getattr(self, "schema", {}) if _specs is None else _specs
1484         self.specs = specs if isinstance(specs, dict) else dict(specs)
1485         self._bound_min, self._bound_max = getattr(
1486             self,
1487             "bounds",
1488             (float("-inf"), float("+inf")),
1489         ) if bounds is None else bounds
1490         if value is not None:
1491             self._value = self._value_sanitize(value)
1492         if default is not None:
1493             default = self._value_sanitize(default)
1494             self.default = self.__class__(
1495                 value=default,
1496                 impl=self.tag,
1497                 expl=self._expl,
1498                 _specs=self.specs,
1499             )
1500             if self._value is None:
1501                 self._value = default
1502
1503     def _value_sanitize(self, value):
1504         if issubclass(value.__class__, Integer):
1505             value = value._value
1506         elif isinstance(value, integer_types):
1507             pass
1508         elif isinstance(value, str):
1509             value = self.specs.get(value)
1510             if value is None:
1511                 raise ObjUnknown("integer value: %s" % value)
1512         else:
1513             raise InvalidValueType((self.__class__, int, str))
1514         if not self._bound_min <= value <= self._bound_max:
1515             raise BoundsError(self._bound_min, value, self._bound_max)
1516         return value
1517
1518     @property
1519     def ready(self):
1520         return self._value is not None
1521
1522     def copy(self):
1523         obj = self.__class__(_specs=self.specs)
1524         obj._value = self._value
1525         obj._bound_min = self._bound_min
1526         obj._bound_max = self._bound_max
1527         obj.tag = self.tag
1528         obj._expl = self._expl
1529         obj.default = self.default
1530         obj.optional = self.optional
1531         obj.offset = self.offset
1532         obj.llen = self.llen
1533         obj.vlen = self.vlen
1534         return obj
1535
1536     def __int__(self):
1537         self._assert_ready()
1538         return int(self._value)
1539
1540     def __hash__(self):
1541         self._assert_ready()
1542         return hash(
1543             self.tag +
1544             bytes(self._expl or b"") +
1545             str(self._value).encode("ascii"),
1546         )
1547
1548     def __eq__(self, their):
1549         if isinstance(their, integer_types):
1550             return self._value == their
1551         if not issubclass(their.__class__, Integer):
1552             return False
1553         return (
1554             self._value == their._value and
1555             self.tag == their.tag and
1556             self._expl == their._expl
1557         )
1558
1559     def __lt__(self, their):
1560         return self._value < their._value
1561
1562     @property
1563     def named(self):
1564         for name, value in self.specs.items():
1565             if value == self._value:
1566                 return name
1567
1568     def __call__(
1569             self,
1570             value=None,
1571             bounds=None,
1572             impl=None,
1573             expl=None,
1574             default=None,
1575             optional=None,
1576     ):
1577         return self.__class__(
1578             value=value,
1579             bounds=(
1580                 (self._bound_min, self._bound_max)
1581                 if bounds is None else bounds
1582             ),
1583             impl=self.tag if impl is None else impl,
1584             expl=self._expl if expl is None else expl,
1585             default=self.default if default is None else default,
1586             optional=self.optional if optional is None else optional,
1587             _specs=self.specs,
1588         )
1589
1590     def _encode(self):
1591         self._assert_ready()
1592         value = self._value
1593         if PY2:
1594             if value == 0:
1595                 octets = bytearray([0])
1596             elif value < 0:
1597                 value = -value
1598                 value -= 1
1599                 octets = bytearray()
1600                 while value > 0:
1601                     octets.append((value & 0xFF) ^ 0xFF)
1602                     value >>= 8
1603                 if len(octets) == 0 or octets[-1] & 0x80 == 0:
1604                     octets.append(0xFF)
1605             else:
1606                 octets = bytearray()
1607                 while value > 0:
1608                     octets.append(value & 0xFF)
1609                     value >>= 8
1610                 if octets[-1] & 0x80 > 0:
1611                     octets.append(0x00)
1612             octets.reverse()
1613             octets = bytes(octets)
1614         else:
1615             bytes_len = ceil(value.bit_length() / 8) or 1
1616             while True:
1617                 try:
1618                     octets = value.to_bytes(
1619                         bytes_len,
1620                         byteorder="big",
1621                         signed=True,
1622                     )
1623                 except OverflowError:
1624                     bytes_len += 1
1625                 else:
1626                     break
1627         return b"".join((self.tag, len_encode(len(octets)), octets))
1628
1629     def _decode(self, tlv, offset, decode_path, ctx):
1630         try:
1631             t, _, lv = tag_strip(tlv)
1632         except DecodeError as err:
1633             raise err.__class__(
1634                 msg=err.msg,
1635                 klass=self.__class__,
1636                 decode_path=decode_path,
1637                 offset=offset,
1638             )
1639         if t != self.tag:
1640             raise TagMismatch(
1641                 klass=self.__class__,
1642                 decode_path=decode_path,
1643                 offset=offset,
1644             )
1645         try:
1646             l, llen, v = len_decode(lv)
1647         except DecodeError as err:
1648             raise err.__class__(
1649                 msg=err.msg,
1650                 klass=self.__class__,
1651                 decode_path=decode_path,
1652                 offset=offset,
1653             )
1654         if l > len(v):
1655             raise NotEnoughData(
1656                 "encoded length is longer than data",
1657                 klass=self.__class__,
1658                 decode_path=decode_path,
1659                 offset=offset,
1660             )
1661         if l == 0:
1662             raise NotEnoughData(
1663                 "zero length",
1664                 klass=self.__class__,
1665                 decode_path=decode_path,
1666                 offset=offset,
1667             )
1668         v, tail = v[:l], v[l:]
1669         first_octet = byte2int(v)
1670         if l > 1:
1671             second_octet = byte2int(v[1:])
1672             if (
1673                     ((first_octet == 0x00) and (second_octet & 0x80 == 0)) or
1674                     ((first_octet == 0xFF) and (second_octet & 0x80 != 0))
1675             ):
1676                 raise DecodeError(
1677                     "non normalized integer",
1678                     klass=self.__class__,
1679                     decode_path=decode_path,
1680                     offset=offset,
1681                 )
1682         if PY2:
1683             value = 0
1684             if first_octet & 0x80 > 0:
1685                 octets = bytearray()
1686                 for octet in bytearray(v):
1687                     octets.append(octet ^ 0xFF)
1688                 for octet in octets:
1689                     value = (value << 8) | octet
1690                 value += 1
1691                 value = -value
1692             else:
1693                 for octet in bytearray(v):
1694                     value = (value << 8) | octet
1695         else:
1696             value = int.from_bytes(v, byteorder="big", signed=True)
1697         try:
1698             obj = self.__class__(
1699                 value=value,
1700                 bounds=(self._bound_min, self._bound_max),
1701                 impl=self.tag,
1702                 expl=self._expl,
1703                 default=self.default,
1704                 optional=self.optional,
1705                 _specs=self.specs,
1706                 _decoded=(offset, llen, l),
1707             )
1708         except BoundsError as err:
1709             raise DecodeError(
1710                 msg=str(err),
1711                 klass=self.__class__,
1712                 decode_path=decode_path,
1713                 offset=offset,
1714             )
1715         return obj, tail
1716
1717     def __repr__(self):
1718         return pp_console_row(next(self.pps()))
1719
1720     def pps(self, decode_path=()):
1721         yield _pp(
1722             asn1_type_name=self.asn1_type_name,
1723             obj_name=self.__class__.__name__,
1724             decode_path=decode_path,
1725             value=(self.named or str(self._value)) if self.ready else None,
1726             optional=self.optional,
1727             default=self == self.default,
1728             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
1729             expl=None if self._expl is None else tag_decode(self._expl),
1730             offset=self.offset,
1731             tlen=self.tlen,
1732             llen=self.llen,
1733             vlen=self.vlen,
1734             expl_offset=self.expl_offset if self.expled else None,
1735             expl_tlen=self.expl_tlen if self.expled else None,
1736             expl_llen=self.expl_llen if self.expled else None,
1737             expl_vlen=self.expl_vlen if self.expled else None,
1738         )
1739
1740
1741 class BitString(Obj):
1742     """``BIT STRING`` bit string type
1743
1744     >>> BitString(b"hello world")
1745     BIT STRING 88 bits 68656c6c6f20776f726c64
1746     >>> bytes(b)
1747     b'hello world'
1748     >>> b == b"hello world"
1749     True
1750     >>> b.bit_len
1751     88
1752
1753     >>> b = BitString("'010110000000'B")
1754     BIT STRING 12 bits 5800
1755     >>> b.bit_len
1756     12
1757     >>> b[0], b[1], b[2], b[3]
1758     (False, True, False, True)
1759     >>> b[1000]
1760     False
1761     >>> [v for v in b]
1762     [False, True, False, True, True, False, False, False, False, False, False, False]
1763
1764     ::
1765
1766         class KeyUsage(BitString):
1767             schema = (
1768                 ('digitalSignature', 0),
1769                 ('nonRepudiation', 1),
1770                 ('keyEncipherment', 2),
1771             )
1772
1773     >>> b = KeyUsage(('keyEncipherment', 'nonRepudiation'))
1774     KeyUsage BIT STRING 3 bits nonRepudiation, keyEncipherment
1775     >>> b.named
1776     ['nonRepudiation', 'keyEncipherment']
1777     >>> b.specs
1778     {'nonRepudiation': 1, 'digitalSignature': 0, 'keyEncipherment': 2}
1779     """
1780     __slots__ = ("specs", "defined")
1781     tag_default = tag_encode(3)
1782     asn1_type_name = "BIT STRING"
1783
1784     def __init__(
1785             self,
1786             value=None,
1787             impl=None,
1788             expl=None,
1789             default=None,
1790             optional=False,
1791             _specs=None,
1792             _decoded=(0, 0, 0),
1793     ):
1794         """
1795         :param value: set the value. Either binary type, tuple of named
1796                       values (if ``schema`` is specified in the class),
1797                       string in ``'XXX...'B`` form, or
1798                       :py:class:`pyderasn.BitString` object
1799         :param bytes impl: override default tag with ``IMPLICIT`` one
1800         :param bytes expl: override default tag with ``EXPLICIT`` one
1801         :param default: set default value. Type same as in ``value``
1802         :param bool optional: is object ``OPTIONAL`` in sequence
1803         """
1804         super(BitString, self).__init__(impl, expl, default, optional, _decoded)
1805         specs = getattr(self, "schema", {}) if _specs is None else _specs
1806         self.specs = specs if isinstance(specs, dict) else dict(specs)
1807         self._value = None if value is None else self._value_sanitize(value)
1808         if default is not None:
1809             default = self._value_sanitize(default)
1810             self.default = self.__class__(
1811                 value=default,
1812                 impl=self.tag,
1813                 expl=self._expl,
1814             )
1815             if value is None:
1816                 self._value = default
1817         self.defined = None
1818
1819     def _bits2octets(self, bits):
1820         if len(self.specs) > 0:
1821             bits = bits.rstrip("0")
1822         bit_len = len(bits)
1823         bits += "0" * ((8 - (bit_len % 8)) % 8)
1824         octets = bytearray(len(bits) // 8)
1825         for i in six_xrange(len(octets)):
1826             octets[i] = int(bits[i * 8:(i * 8) + 8], 2)
1827         return bit_len, bytes(octets)
1828
1829     def _value_sanitize(self, value):
1830         if issubclass(value.__class__, BitString):
1831             return value._value
1832         if isinstance(value, (string_types, binary_type)):
1833             if (
1834                     isinstance(value, string_types) and
1835                     value.startswith("'") and
1836                     value.endswith("'B")
1837             ):
1838                 value = value[1:-2]
1839                 if not set(value) <= set(("0", "1")):
1840                     raise ValueError("B's coding contains unacceptable chars")
1841                 return self._bits2octets(value)
1842             elif isinstance(value, binary_type):
1843                 return (len(value) * 8, value)
1844             else:
1845                 raise InvalidValueType((
1846                     self.__class__,
1847                     string_types,
1848                     binary_type,
1849                 ))
1850         if isinstance(value, tuple):
1851             if (
1852                     len(value) == 2 and
1853                     isinstance(value[0], integer_types) and
1854                     isinstance(value[1], binary_type)
1855             ):
1856                 return value
1857             bits = []
1858             for name in value:
1859                 bit = self.specs.get(name)
1860                 if bit is None:
1861                     raise ObjUnknown("BitString value: %s" % name)
1862                 bits.append(bit)
1863             if len(bits) == 0:
1864                 return self._bits2octets("")
1865             bits = set(bits)
1866             return self._bits2octets("".join(
1867                 ("1" if bit in bits else "0")
1868                 for bit in six_xrange(max(bits) + 1)
1869             ))
1870         raise InvalidValueType((self.__class__, binary_type, string_types))
1871
1872     @property
1873     def ready(self):
1874         return self._value is not None
1875
1876     def copy(self):
1877         obj = self.__class__(_specs=self.specs)
1878         value = self._value
1879         if value is not None:
1880             value = (value[0], value[1])
1881         obj._value = value
1882         obj.tag = self.tag
1883         obj._expl = self._expl
1884         obj.default = self.default
1885         obj.optional = self.optional
1886         obj.offset = self.offset
1887         obj.llen = self.llen
1888         obj.vlen = self.vlen
1889         return obj
1890
1891     def __iter__(self):
1892         self._assert_ready()
1893         for i in six_xrange(self._value[0]):
1894             yield self[i]
1895
1896     @property
1897     def bit_len(self):
1898         self._assert_ready()
1899         return self._value[0]
1900
1901     def __bytes__(self):
1902         self._assert_ready()
1903         return self._value[1]
1904
1905     def __eq__(self, their):
1906         if isinstance(their, bytes):
1907             return self._value[1] == their
1908         if not issubclass(their.__class__, BitString):
1909             return False
1910         return (
1911             self._value == their._value and
1912             self.tag == their.tag and
1913             self._expl == their._expl
1914         )
1915
1916     @property
1917     def named(self):
1918         return [name for name, bit in self.specs.items() if self[bit]]
1919
1920     def __call__(
1921             self,
1922             value=None,
1923             impl=None,
1924             expl=None,
1925             default=None,
1926             optional=None,
1927     ):
1928         return self.__class__(
1929             value=value,
1930             impl=self.tag if impl is None else impl,
1931             expl=self._expl if expl is None else expl,
1932             default=self.default if default is None else default,
1933             optional=self.optional if optional is None else optional,
1934             _specs=self.specs,
1935         )
1936
1937     def __getitem__(self, key):
1938         if isinstance(key, int):
1939             bit_len, octets = self._value
1940             if key >= bit_len:
1941                 return False
1942             return (
1943                 byte2int(memoryview(octets)[key // 8:]) >>
1944                 (7 - (key % 8))
1945             ) & 1 == 1
1946         if isinstance(key, string_types):
1947             value = self.specs.get(key)
1948             if value is None:
1949                 raise ObjUnknown("BitString value: %s" % key)
1950             return self[value]
1951         raise InvalidValueType((int, str))
1952
1953     def _encode(self):
1954         self._assert_ready()
1955         bit_len, octets = self._value
1956         return b"".join((
1957             self.tag,
1958             len_encode(len(octets) + 1),
1959             int2byte((8 - bit_len % 8) % 8),
1960             octets,
1961         ))
1962
1963     def _decode(self, tlv, offset, decode_path, ctx):
1964         try:
1965             t, _, lv = tag_strip(tlv)
1966         except DecodeError as err:
1967             raise err.__class__(
1968                 msg=err.msg,
1969                 klass=self.__class__,
1970                 decode_path=decode_path,
1971                 offset=offset,
1972             )
1973         if t != self.tag:
1974             raise TagMismatch(
1975                 klass=self.__class__,
1976                 decode_path=decode_path,
1977                 offset=offset,
1978             )
1979         try:
1980             l, llen, v = len_decode(lv)
1981         except DecodeError as err:
1982             raise err.__class__(
1983                 msg=err.msg,
1984                 klass=self.__class__,
1985                 decode_path=decode_path,
1986                 offset=offset,
1987             )
1988         if l > len(v):
1989             raise NotEnoughData(
1990                 "encoded length is longer than data",
1991                 klass=self.__class__,
1992                 decode_path=decode_path,
1993                 offset=offset,
1994             )
1995         if l == 0:
1996             raise NotEnoughData(
1997                 "zero length",
1998                 klass=self.__class__,
1999                 decode_path=decode_path,
2000                 offset=offset,
2001             )
2002         pad_size = byte2int(v)
2003         if l == 1 and pad_size != 0:
2004             raise DecodeError(
2005                 "invalid empty value",
2006                 klass=self.__class__,
2007                 decode_path=decode_path,
2008                 offset=offset,
2009             )
2010         if pad_size > 7:
2011             raise DecodeError(
2012                 "too big pad",
2013                 klass=self.__class__,
2014                 decode_path=decode_path,
2015                 offset=offset,
2016             )
2017         if byte2int(v[-1:]) & ((1 << pad_size) - 1) != 0:
2018             raise DecodeError(
2019                 "invalid pad",
2020                 klass=self.__class__,
2021                 decode_path=decode_path,
2022                 offset=offset,
2023             )
2024         v, tail = v[:l], v[l:]
2025         obj = self.__class__(
2026             value=((len(v) - 1) * 8 - pad_size, v[1:].tobytes()),
2027             impl=self.tag,
2028             expl=self._expl,
2029             default=self.default,
2030             optional=self.optional,
2031             _specs=self.specs,
2032             _decoded=(offset, llen, l),
2033         )
2034         return obj, tail
2035
2036     def __repr__(self):
2037         return pp_console_row(next(self.pps()))
2038
2039     def pps(self, decode_path=()):
2040         value = None
2041         blob = None
2042         if self.ready:
2043             bit_len, blob = self._value
2044             value = "%d bits" % bit_len
2045             if len(self.specs) > 0:
2046                 blob = tuple(self.named)
2047         yield _pp(
2048             asn1_type_name=self.asn1_type_name,
2049             obj_name=self.__class__.__name__,
2050             decode_path=decode_path,
2051             value=value,
2052             blob=blob,
2053             optional=self.optional,
2054             default=self == self.default,
2055             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
2056             expl=None if self._expl is None else tag_decode(self._expl),
2057             offset=self.offset,
2058             tlen=self.tlen,
2059             llen=self.llen,
2060             vlen=self.vlen,
2061             expl_offset=self.expl_offset if self.expled else None,
2062             expl_tlen=self.expl_tlen if self.expled else None,
2063             expl_llen=self.expl_llen if self.expled else None,
2064             expl_vlen=self.expl_vlen if self.expled else None,
2065         )
2066         defined_by, defined = self.defined or (None, None)
2067         if defined_by is not None:
2068             yield defined.pps(
2069                 decode_path=decode_path + (DecodePathDefBy(defined_by),)
2070             )
2071
2072
2073 class OctetString(Obj):
2074     """``OCTET STRING`` binary string type
2075
2076     >>> s = OctetString(b"hello world")
2077     OCTET STRING 11 bytes 68656c6c6f20776f726c64
2078     >>> s == OctetString(b"hello world")
2079     True
2080     >>> bytes(s)
2081     b'hello world'
2082
2083     >>> OctetString(b"hello", bounds=(4, 4))
2084     Traceback (most recent call last):
2085     pyderasn.BoundsError: unsatisfied bounds: 4 <= 5 <= 4
2086     >>> OctetString(b"hell", bounds=(4, 4))
2087     OCTET STRING 4 bytes 68656c6c
2088     """
2089     __slots__ = ("_bound_min", "_bound_max", "defined")
2090     tag_default = tag_encode(4)
2091     asn1_type_name = "OCTET STRING"
2092
2093     def __init__(
2094             self,
2095             value=None,
2096             bounds=None,
2097             impl=None,
2098             expl=None,
2099             default=None,
2100             optional=False,
2101             _decoded=(0, 0, 0),
2102     ):
2103         """
2104         :param value: set the value. Either binary type, or
2105                       :py:class:`pyderasn.OctetString` object
2106         :param bounds: set ``(MIN, MAX)`` value size constraint.
2107                        (-inf, +inf) by default
2108         :param bytes impl: override default tag with ``IMPLICIT`` one
2109         :param bytes expl: override default tag with ``EXPLICIT`` one
2110         :param default: set default value. Type same as in ``value``
2111         :param bool optional: is object ``OPTIONAL`` in sequence
2112         """
2113         super(OctetString, self).__init__(
2114             impl,
2115             expl,
2116             default,
2117             optional,
2118             _decoded,
2119         )
2120         self._value = value
2121         self._bound_min, self._bound_max = getattr(
2122             self,
2123             "bounds",
2124             (0, float("+inf")),
2125         ) if bounds is None else bounds
2126         if value is not None:
2127             self._value = self._value_sanitize(value)
2128         if default is not None:
2129             default = self._value_sanitize(default)
2130             self.default = self.__class__(
2131                 value=default,
2132                 impl=self.tag,
2133                 expl=self._expl,
2134             )
2135             if self._value is None:
2136                 self._value = default
2137         self.defined = None
2138
2139     def _value_sanitize(self, value):
2140         if issubclass(value.__class__, OctetString):
2141             value = value._value
2142         elif isinstance(value, binary_type):
2143             pass
2144         else:
2145             raise InvalidValueType((self.__class__, bytes))
2146         if not self._bound_min <= len(value) <= self._bound_max:
2147             raise BoundsError(self._bound_min, len(value), self._bound_max)
2148         return value
2149
2150     @property
2151     def ready(self):
2152         return self._value is not None
2153
2154     def copy(self):
2155         obj = self.__class__()
2156         obj._value = self._value
2157         obj._bound_min = self._bound_min
2158         obj._bound_max = self._bound_max
2159         obj.tag = self.tag
2160         obj._expl = self._expl
2161         obj.default = self.default
2162         obj.optional = self.optional
2163         obj.offset = self.offset
2164         obj.llen = self.llen
2165         obj.vlen = self.vlen
2166         return obj
2167
2168     def __bytes__(self):
2169         self._assert_ready()
2170         return self._value
2171
2172     def __eq__(self, their):
2173         if isinstance(their, binary_type):
2174             return self._value == their
2175         if not issubclass(their.__class__, OctetString):
2176             return False
2177         return (
2178             self._value == their._value and
2179             self.tag == their.tag and
2180             self._expl == their._expl
2181         )
2182
2183     def __lt__(self, their):
2184         return self._value < their._value
2185
2186     def __call__(
2187             self,
2188             value=None,
2189             bounds=None,
2190             impl=None,
2191             expl=None,
2192             default=None,
2193             optional=None,
2194     ):
2195         return self.__class__(
2196             value=value,
2197             bounds=(
2198                 (self._bound_min, self._bound_max)
2199                 if bounds is None else bounds
2200             ),
2201             impl=self.tag if impl is None else impl,
2202             expl=self._expl if expl is None else expl,
2203             default=self.default if default is None else default,
2204             optional=self.optional if optional is None else optional,
2205         )
2206
2207     def _encode(self):
2208         self._assert_ready()
2209         return b"".join((
2210             self.tag,
2211             len_encode(len(self._value)),
2212             self._value,
2213         ))
2214
2215     def _decode(self, tlv, offset, decode_path, ctx):
2216         try:
2217             t, _, lv = tag_strip(tlv)
2218         except DecodeError as err:
2219             raise err.__class__(
2220                 msg=err.msg,
2221                 klass=self.__class__,
2222                 decode_path=decode_path,
2223                 offset=offset,
2224             )
2225         if t != self.tag:
2226             raise TagMismatch(
2227                 klass=self.__class__,
2228                 decode_path=decode_path,
2229                 offset=offset,
2230             )
2231         try:
2232             l, llen, v = len_decode(lv)
2233         except DecodeError as err:
2234             raise err.__class__(
2235                 msg=err.msg,
2236                 klass=self.__class__,
2237                 decode_path=decode_path,
2238                 offset=offset,
2239             )
2240         if l > len(v):
2241             raise NotEnoughData(
2242                 "encoded length is longer than data",
2243                 klass=self.__class__,
2244                 decode_path=decode_path,
2245                 offset=offset,
2246             )
2247         v, tail = v[:l], v[l:]
2248         try:
2249             obj = self.__class__(
2250                 value=v.tobytes(),
2251                 bounds=(self._bound_min, self._bound_max),
2252                 impl=self.tag,
2253                 expl=self._expl,
2254                 default=self.default,
2255                 optional=self.optional,
2256                 _decoded=(offset, llen, l),
2257             )
2258         except BoundsError as err:
2259             raise DecodeError(
2260                 msg=str(err),
2261                 klass=self.__class__,
2262                 decode_path=decode_path,
2263                 offset=offset,
2264             )
2265         return obj, tail
2266
2267     def __repr__(self):
2268         return pp_console_row(next(self.pps()))
2269
2270     def pps(self, decode_path=()):
2271         yield _pp(
2272             asn1_type_name=self.asn1_type_name,
2273             obj_name=self.__class__.__name__,
2274             decode_path=decode_path,
2275             value=("%d bytes" % len(self._value)) if self.ready else None,
2276             blob=self._value if self.ready else None,
2277             optional=self.optional,
2278             default=self == self.default,
2279             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
2280             expl=None if self._expl is None else tag_decode(self._expl),
2281             offset=self.offset,
2282             tlen=self.tlen,
2283             llen=self.llen,
2284             vlen=self.vlen,
2285             expl_offset=self.expl_offset if self.expled else None,
2286             expl_tlen=self.expl_tlen if self.expled else None,
2287             expl_llen=self.expl_llen if self.expled else None,
2288             expl_vlen=self.expl_vlen if self.expled else None,
2289         )
2290         defined_by, defined = self.defined or (None, None)
2291         if defined_by is not None:
2292             yield defined.pps(
2293                 decode_path=decode_path + (DecodePathDefBy(defined_by),)
2294             )
2295
2296
2297 class Null(Obj):
2298     """``NULL`` null object
2299
2300     >>> n = Null()
2301     NULL
2302     >>> n.ready
2303     True
2304     """
2305     __slots__ = ()
2306     tag_default = tag_encode(5)
2307     asn1_type_name = "NULL"
2308
2309     def __init__(
2310             self,
2311             value=None,  # unused, but Sequence passes it
2312             impl=None,
2313             expl=None,
2314             optional=False,
2315             _decoded=(0, 0, 0),
2316     ):
2317         """
2318         :param bytes impl: override default tag with ``IMPLICIT`` one
2319         :param bytes expl: override default tag with ``EXPLICIT`` one
2320         :param bool optional: is object ``OPTIONAL`` in sequence
2321         """
2322         super(Null, self).__init__(impl, expl, None, optional, _decoded)
2323         self.default = None
2324
2325     @property
2326     def ready(self):
2327         return True
2328
2329     def copy(self):
2330         obj = self.__class__()
2331         obj.tag = self.tag
2332         obj._expl = self._expl
2333         obj.default = self.default
2334         obj.optional = self.optional
2335         obj.offset = self.offset
2336         obj.llen = self.llen
2337         obj.vlen = self.vlen
2338         return obj
2339
2340     def __eq__(self, their):
2341         if not issubclass(their.__class__, Null):
2342             return False
2343         return (
2344             self.tag == their.tag and
2345             self._expl == their._expl
2346         )
2347
2348     def __call__(
2349             self,
2350             value=None,
2351             impl=None,
2352             expl=None,
2353             optional=None,
2354     ):
2355         return self.__class__(
2356             impl=self.tag if impl is None else impl,
2357             expl=self._expl if expl is None else expl,
2358             optional=self.optional if optional is None else optional,
2359         )
2360
2361     def _encode(self):
2362         return self.tag + len_encode(0)
2363
2364     def _decode(self, tlv, offset, decode_path, ctx):
2365         try:
2366             t, _, lv = tag_strip(tlv)
2367         except DecodeError as err:
2368             raise err.__class__(
2369                 msg=err.msg,
2370                 klass=self.__class__,
2371                 decode_path=decode_path,
2372                 offset=offset,
2373             )
2374         if t != self.tag:
2375             raise TagMismatch(
2376                 klass=self.__class__,
2377                 decode_path=decode_path,
2378                 offset=offset,
2379             )
2380         try:
2381             l, _, v = len_decode(lv)
2382         except DecodeError as err:
2383             raise err.__class__(
2384                 msg=err.msg,
2385                 klass=self.__class__,
2386                 decode_path=decode_path,
2387                 offset=offset,
2388             )
2389         if l != 0:
2390             raise InvalidLength(
2391                 "Null must have zero length",
2392                 klass=self.__class__,
2393                 decode_path=decode_path,
2394                 offset=offset,
2395             )
2396         obj = self.__class__(
2397             impl=self.tag,
2398             expl=self._expl,
2399             optional=self.optional,
2400             _decoded=(offset, 1, 0),
2401         )
2402         return obj, v
2403
2404     def __repr__(self):
2405         return pp_console_row(next(self.pps()))
2406
2407     def pps(self, decode_path=()):
2408         yield _pp(
2409             asn1_type_name=self.asn1_type_name,
2410             obj_name=self.__class__.__name__,
2411             decode_path=decode_path,
2412             optional=self.optional,
2413             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
2414             expl=None if self._expl is None else tag_decode(self._expl),
2415             offset=self.offset,
2416             tlen=self.tlen,
2417             llen=self.llen,
2418             vlen=self.vlen,
2419             expl_offset=self.expl_offset if self.expled else None,
2420             expl_tlen=self.expl_tlen if self.expled else None,
2421             expl_llen=self.expl_llen if self.expled else None,
2422             expl_vlen=self.expl_vlen if self.expled else None,
2423         )
2424
2425
2426 class ObjectIdentifier(Obj):
2427     """``OBJECT IDENTIFIER`` OID type
2428
2429     >>> oid = ObjectIdentifier((1, 2, 3))
2430     OBJECT IDENTIFIER 1.2.3
2431     >>> oid == ObjectIdentifier("1.2.3")
2432     True
2433     >>> tuple(oid)
2434     (1, 2, 3)
2435     >>> str(oid)
2436     '1.2.3'
2437     >>> oid + (4, 5) + ObjectIdentifier("1.7")
2438     OBJECT IDENTIFIER 1.2.3.4.5.1.7
2439
2440     >>> str(ObjectIdentifier((3, 1)))
2441     Traceback (most recent call last):
2442     pyderasn.InvalidOID: unacceptable first arc value
2443     """
2444     __slots__ = ("defines",)
2445     tag_default = tag_encode(6)
2446     asn1_type_name = "OBJECT IDENTIFIER"
2447
2448     def __init__(
2449             self,
2450             value=None,
2451             defines=(),
2452             impl=None,
2453             expl=None,
2454             default=None,
2455             optional=False,
2456             _decoded=(0, 0, 0),
2457     ):
2458         """
2459         :param value: set the value. Either tuples of integers,
2460                       string of "."-concatenated integers, or
2461                       :py:class:`pyderasn.ObjectIdentifier` object
2462         :param defines: sequence of tuples. Each tuple has two elements.
2463                         First one is relative to current one decode
2464                         path, aiming to the field defined by that OID.
2465                         Read about relative path in
2466                         :py:func:`pyderasn.abs_decode_path`. Second
2467                         tuple element is ``{OID: pyderasn.Obj()}``
2468                         dictionary, mapping between current OID value
2469                         and structure applied to defined field.
2470                         :ref:`Read about DEFINED BY <definedby>`
2471         :param bytes impl: override default tag with ``IMPLICIT`` one
2472         :param bytes expl: override default tag with ``EXPLICIT`` one
2473         :param default: set default value. Type same as in ``value``
2474         :param bool optional: is object ``OPTIONAL`` in sequence
2475         """
2476         super(ObjectIdentifier, self).__init__(
2477             impl,
2478             expl,
2479             default,
2480             optional,
2481             _decoded,
2482         )
2483         self._value = value
2484         if value is not None:
2485             self._value = self._value_sanitize(value)
2486         if default is not None:
2487             default = self._value_sanitize(default)
2488             self.default = self.__class__(
2489                 value=default,
2490                 impl=self.tag,
2491                 expl=self._expl,
2492             )
2493             if self._value is None:
2494                 self._value = default
2495         self.defines = defines
2496
2497     def __add__(self, their):
2498         if isinstance(their, self.__class__):
2499             return self.__class__(self._value + their._value)
2500         if isinstance(their, tuple):
2501             return self.__class__(self._value + their)
2502         raise InvalidValueType((self.__class__, tuple))
2503
2504     def _value_sanitize(self, value):
2505         if issubclass(value.__class__, ObjectIdentifier):
2506             return value._value
2507         if isinstance(value, string_types):
2508             try:
2509                 value = tuple(int(arc) for arc in value.split("."))
2510             except ValueError:
2511                 raise InvalidOID("unacceptable arcs values")
2512         if isinstance(value, tuple):
2513             if len(value) < 2:
2514                 raise InvalidOID("less than 2 arcs")
2515             first_arc = value[0]
2516             if first_arc in (0, 1):
2517                 if not (0 <= value[1] <= 39):
2518                     raise InvalidOID("second arc is too wide")
2519             elif first_arc == 2:
2520                 pass
2521             else:
2522                 raise InvalidOID("unacceptable first arc value")
2523             return value
2524         raise InvalidValueType((self.__class__, str, tuple))
2525
2526     @property
2527     def ready(self):
2528         return self._value is not None
2529
2530     def copy(self):
2531         obj = self.__class__()
2532         obj._value = self._value
2533         obj.defines = self.defines
2534         obj.tag = self.tag
2535         obj._expl = self._expl
2536         obj.default = self.default
2537         obj.optional = self.optional
2538         obj.offset = self.offset
2539         obj.llen = self.llen
2540         obj.vlen = self.vlen
2541         return obj
2542
2543     def __iter__(self):
2544         self._assert_ready()
2545         return iter(self._value)
2546
2547     def __str__(self):
2548         return ".".join(str(arc) for arc in self._value or ())
2549
2550     def __hash__(self):
2551         self._assert_ready()
2552         return hash(
2553             self.tag +
2554             bytes(self._expl or b"") +
2555             str(self._value).encode("ascii"),
2556         )
2557
2558     def __eq__(self, their):
2559         if isinstance(their, tuple):
2560             return self._value == their
2561         if not issubclass(their.__class__, ObjectIdentifier):
2562             return False
2563         return (
2564             self.tag == their.tag and
2565             self._expl == their._expl and
2566             self._value == their._value
2567         )
2568
2569     def __lt__(self, their):
2570         return self._value < their._value
2571
2572     def __call__(
2573             self,
2574             value=None,
2575             defines=None,
2576             impl=None,
2577             expl=None,
2578             default=None,
2579             optional=None,
2580     ):
2581         return self.__class__(
2582             value=value,
2583             defines=self.defines if defines is None else defines,
2584             impl=self.tag if impl is None else impl,
2585             expl=self._expl if expl is None else expl,
2586             default=self.default if default is None else default,
2587             optional=self.optional if optional is None else optional,
2588         )
2589
2590     def _encode(self):
2591         self._assert_ready()
2592         value = self._value
2593         first_value = value[1]
2594         first_arc = value[0]
2595         if first_arc == 0:
2596             pass
2597         elif first_arc == 1:
2598             first_value += 40
2599         elif first_arc == 2:
2600             first_value += 80
2601         else:  # pragma: no cover
2602             raise RuntimeError("invalid arc is stored")
2603         octets = [zero_ended_encode(first_value)]
2604         for arc in value[2:]:
2605             octets.append(zero_ended_encode(arc))
2606         v = b"".join(octets)
2607         return b"".join((self.tag, len_encode(len(v)), v))
2608
2609     def _decode(self, tlv, offset, decode_path, ctx):
2610         try:
2611             t, _, lv = tag_strip(tlv)
2612         except DecodeError as err:
2613             raise err.__class__(
2614                 msg=err.msg,
2615                 klass=self.__class__,
2616                 decode_path=decode_path,
2617                 offset=offset,
2618             )
2619         if t != self.tag:
2620             raise TagMismatch(
2621                 klass=self.__class__,
2622                 decode_path=decode_path,
2623                 offset=offset,
2624             )
2625         try:
2626             l, llen, v = len_decode(lv)
2627         except DecodeError as err:
2628             raise err.__class__(
2629                 msg=err.msg,
2630                 klass=self.__class__,
2631                 decode_path=decode_path,
2632                 offset=offset,
2633             )
2634         if l > len(v):
2635             raise NotEnoughData(
2636                 "encoded length is longer than data",
2637                 klass=self.__class__,
2638                 decode_path=decode_path,
2639                 offset=offset,
2640             )
2641         if l == 0:
2642             raise NotEnoughData(
2643                 "zero length",
2644                 klass=self.__class__,
2645                 decode_path=decode_path,
2646                 offset=offset,
2647             )
2648         v, tail = v[:l], v[l:]
2649         arcs = []
2650         while len(v) > 0:
2651             i = 0
2652             arc = 0
2653             while True:
2654                 octet = indexbytes(v, i)
2655                 arc = (arc << 7) | (octet & 0x7F)
2656                 if octet & 0x80 == 0:
2657                     arcs.append(arc)
2658                     v = v[i + 1:]
2659                     break
2660                 i += 1
2661                 if i == len(v):
2662                     raise DecodeError(
2663                         "unfinished OID",
2664                         klass=self.__class__,
2665                         decode_path=decode_path,
2666                         offset=offset,
2667                     )
2668         first_arc = 0
2669         second_arc = arcs[0]
2670         if 0 <= second_arc <= 39:
2671             first_arc = 0
2672         elif 40 <= second_arc <= 79:
2673             first_arc = 1
2674             second_arc -= 40
2675         else:
2676             first_arc = 2
2677             second_arc -= 80
2678         obj = self.__class__(
2679             value=tuple([first_arc, second_arc] + arcs[1:]),
2680             impl=self.tag,
2681             expl=self._expl,
2682             default=self.default,
2683             optional=self.optional,
2684             _decoded=(offset, llen, l),
2685         )
2686         return obj, tail
2687
2688     def __repr__(self):
2689         return pp_console_row(next(self.pps()))
2690
2691     def pps(self, decode_path=()):
2692         yield _pp(
2693             asn1_type_name=self.asn1_type_name,
2694             obj_name=self.__class__.__name__,
2695             decode_path=decode_path,
2696             value=str(self) if self.ready else None,
2697             optional=self.optional,
2698             default=self == self.default,
2699             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
2700             expl=None if self._expl is None else tag_decode(self._expl),
2701             offset=self.offset,
2702             tlen=self.tlen,
2703             llen=self.llen,
2704             vlen=self.vlen,
2705             expl_offset=self.expl_offset if self.expled else None,
2706             expl_tlen=self.expl_tlen if self.expled else None,
2707             expl_llen=self.expl_llen if self.expled else None,
2708             expl_vlen=self.expl_vlen if self.expled else None,
2709         )
2710
2711
2712 class Enumerated(Integer):
2713     """``ENUMERATED`` integer type
2714
2715     This type is identical to :py:class:`pyderasn.Integer`, but requires
2716     schema to be specified and does not accept values missing from it.
2717     """
2718     __slots__ = ()
2719     tag_default = tag_encode(10)
2720     asn1_type_name = "ENUMERATED"
2721
2722     def __init__(
2723             self,
2724             value=None,
2725             impl=None,
2726             expl=None,
2727             default=None,
2728             optional=False,
2729             _specs=None,
2730             _decoded=(0, 0, 0),
2731             bounds=None,  # dummy argument, workability for Integer.decode
2732     ):
2733         super(Enumerated, self).__init__(
2734             value=value,
2735             impl=impl,
2736             expl=expl,
2737             default=default,
2738             optional=optional,
2739             _specs=_specs,
2740             _decoded=_decoded,
2741         )
2742         if len(self.specs) == 0:
2743             raise ValueError("schema must be specified")
2744
2745     def _value_sanitize(self, value):
2746         if isinstance(value, self.__class__):
2747             value = value._value
2748         elif isinstance(value, integer_types):
2749             if value not in list(self.specs.values()):
2750                 raise DecodeError(
2751                     "unknown integer value: %s" % value,
2752                     klass=self.__class__,
2753                 )
2754         elif isinstance(value, string_types):
2755             value = self.specs.get(value)
2756             if value is None:
2757                 raise ObjUnknown("integer value: %s" % value)
2758         else:
2759             raise InvalidValueType((self.__class__, int, str))
2760         return value
2761
2762     def copy(self):
2763         obj = self.__class__(_specs=self.specs)
2764         obj._value = self._value
2765         obj._bound_min = self._bound_min
2766         obj._bound_max = self._bound_max
2767         obj.tag = self.tag
2768         obj._expl = self._expl
2769         obj.default = self.default
2770         obj.optional = self.optional
2771         obj.offset = self.offset
2772         obj.llen = self.llen
2773         obj.vlen = self.vlen
2774         return obj
2775
2776     def __call__(
2777             self,
2778             value=None,
2779             impl=None,
2780             expl=None,
2781             default=None,
2782             optional=None,
2783             _specs=None,
2784     ):
2785         return self.__class__(
2786             value=value,
2787             impl=self.tag if impl is None else impl,
2788             expl=self._expl if expl is None else expl,
2789             default=self.default if default is None else default,
2790             optional=self.optional if optional is None else optional,
2791             _specs=self.specs,
2792         )
2793
2794
2795 class CommonString(OctetString):
2796     """Common class for all strings
2797
2798     Everything resembles :py:class:`pyderasn.OctetString`, except
2799     ability to deal with unicode text strings.
2800
2801     >>> hexenc("привет мир".encode("utf-8"))
2802     'd0bfd180d0b8d0b2d0b5d18220d0bcd0b8d180'
2803     >>> UTF8String("привет мир") == UTF8String(hexdec("d0...80"))
2804     True
2805     >>> s = UTF8String("привет мир")
2806     UTF8String UTF8String привет мир
2807     >>> str(s)
2808     'привет мир'
2809     >>> hexenc(bytes(s))
2810     'd0bfd180d0b8d0b2d0b5d18220d0bcd0b8d180'
2811
2812     >>> PrintableString("привет мир")
2813     Traceback (most recent call last):
2814     UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-5: ordinal not in range(128)
2815
2816     >>> BMPString("ада", bounds=(2, 2))
2817     Traceback (most recent call last):
2818     pyderasn.BoundsError: unsatisfied bounds: 2 <= 3 <= 2
2819     >>> s = BMPString("ад", bounds=(2, 2))
2820     >>> s.encoding
2821     'utf-16-be'
2822     >>> hexenc(bytes(s))
2823     '04300434'
2824
2825     .. list-table::
2826        :header-rows: 1
2827
2828        * - Class
2829          - Text Encoding
2830        * - :py:class:`pyderasn.UTF8String`
2831          - utf-8
2832        * - :py:class:`pyderasn.NumericString`
2833          - ascii
2834        * - :py:class:`pyderasn.PrintableString`
2835          - ascii
2836        * - :py:class:`pyderasn.TeletexString`
2837          - ascii
2838        * - :py:class:`pyderasn.T61String`
2839          - ascii
2840        * - :py:class:`pyderasn.VideotexString`
2841          - iso-8859-1
2842        * - :py:class:`pyderasn.IA5String`
2843          - ascii
2844        * - :py:class:`pyderasn.GraphicString`
2845          - iso-8859-1
2846        * - :py:class:`pyderasn.VisibleString`
2847          - ascii
2848        * - :py:class:`pyderasn.ISO646String`
2849          - ascii
2850        * - :py:class:`pyderasn.GeneralString`
2851          - iso-8859-1
2852        * - :py:class:`pyderasn.UniversalString`
2853          - utf-32-be
2854        * - :py:class:`pyderasn.BMPString`
2855          - utf-16-be
2856     """
2857     __slots__ = ("encoding",)
2858
2859     def _value_sanitize(self, value):
2860         value_raw = None
2861         value_decoded = None
2862         if isinstance(value, self.__class__):
2863             value_raw = value._value
2864         elif isinstance(value, text_type):
2865             value_decoded = value
2866         elif isinstance(value, binary_type):
2867             value_raw = value
2868         else:
2869             raise InvalidValueType((self.__class__, text_type, binary_type))
2870         value_raw = (
2871             value_decoded.encode(self.encoding)
2872             if value_raw is None else value_raw
2873         )
2874         value_decoded = (
2875             value_raw.decode(self.encoding)
2876             if value_decoded is None else value_decoded
2877         )
2878         if not self._bound_min <= len(value_decoded) <= self._bound_max:
2879             raise BoundsError(
2880                 self._bound_min,
2881                 len(value_decoded),
2882                 self._bound_max,
2883             )
2884         return value_raw
2885
2886     def __eq__(self, their):
2887         if isinstance(their, binary_type):
2888             return self._value == their
2889         if isinstance(their, text_type):
2890             return self._value == their.encode(self.encoding)
2891         if not isinstance(their, self.__class__):
2892             return False
2893         return (
2894             self._value == their._value and
2895             self.tag == their.tag and
2896             self._expl == their._expl
2897         )
2898
2899     def __unicode__(self):
2900         if self.ready:
2901             return self._value.decode(self.encoding)
2902         return text_type(self._value)
2903
2904     def __repr__(self):
2905         return pp_console_row(next(self.pps(no_unicode=PY2)))
2906
2907     def pps(self, decode_path=(), no_unicode=False):
2908         value = None
2909         if self.ready:
2910             value = hexenc(bytes(self)) if no_unicode else self.__unicode__()
2911         yield _pp(
2912             asn1_type_name=self.asn1_type_name,
2913             obj_name=self.__class__.__name__,
2914             decode_path=decode_path,
2915             value=value,
2916             optional=self.optional,
2917             default=self == self.default,
2918             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
2919             expl=None if self._expl is None else tag_decode(self._expl),
2920             offset=self.offset,
2921             tlen=self.tlen,
2922             llen=self.llen,
2923             vlen=self.vlen,
2924         )
2925
2926
2927 class UTF8String(CommonString):
2928     __slots__ = ()
2929     tag_default = tag_encode(12)
2930     encoding = "utf-8"
2931     asn1_type_name = "UTF8String"
2932
2933
2934 class NumericString(CommonString):
2935     __slots__ = ()
2936     tag_default = tag_encode(18)
2937     encoding = "ascii"
2938     asn1_type_name = "NumericString"
2939
2940
2941 class PrintableString(CommonString):
2942     __slots__ = ()
2943     tag_default = tag_encode(19)
2944     encoding = "ascii"
2945     asn1_type_name = "PrintableString"
2946
2947
2948 class TeletexString(CommonString):
2949     __slots__ = ()
2950     tag_default = tag_encode(20)
2951     encoding = "ascii"
2952     asn1_type_name = "TeletexString"
2953
2954
2955 class T61String(TeletexString):
2956     __slots__ = ()
2957     asn1_type_name = "T61String"
2958
2959
2960 class VideotexString(CommonString):
2961     __slots__ = ()
2962     tag_default = tag_encode(21)
2963     encoding = "iso-8859-1"
2964     asn1_type_name = "VideotexString"
2965
2966
2967 class IA5String(CommonString):
2968     __slots__ = ()
2969     tag_default = tag_encode(22)
2970     encoding = "ascii"
2971     asn1_type_name = "IA5"
2972
2973
2974 LEN_YYMMDDHHMMSSZ = len("YYMMDDHHMMSSZ")
2975 LEN_YYYYMMDDHHMMSSDMZ = len("YYYYMMDDHHMMSSDMZ")
2976 LEN_YYYYMMDDHHMMSSZ = len("YYYYMMDDHHMMSSZ")
2977
2978
2979 class UTCTime(CommonString):
2980     """``UTCTime`` datetime type
2981
2982     >>> t = UTCTime(datetime(2017, 9, 30, 22, 7, 50, 123))
2983     UTCTime UTCTime 2017-09-30T22:07:50
2984     >>> str(t)
2985     '170930220750Z'
2986     >>> bytes(t)
2987     b'170930220750Z'
2988     >>> t.todatetime()
2989     datetime.datetime(2017, 9, 30, 22, 7, 50)
2990     >>> UTCTime(datetime(2057, 9, 30, 22, 7, 50)).todatetime()
2991     datetime.datetime(1957, 9, 30, 22, 7, 50)
2992     """
2993     __slots__ = ()
2994     tag_default = tag_encode(23)
2995     encoding = "ascii"
2996     asn1_type_name = "UTCTime"
2997
2998     fmt = "%y%m%d%H%M%SZ"
2999
3000     def __init__(
3001             self,
3002             value=None,
3003             impl=None,
3004             expl=None,
3005             default=None,
3006             optional=False,
3007             _decoded=(0, 0, 0),
3008             bounds=None,  # dummy argument, workability for OctetString.decode
3009     ):
3010         """
3011         :param value: set the value. Either datetime type, or
3012                       :py:class:`pyderasn.UTCTime` object
3013         :param bytes impl: override default tag with ``IMPLICIT`` one
3014         :param bytes expl: override default tag with ``EXPLICIT`` one
3015         :param default: set default value. Type same as in ``value``
3016         :param bool optional: is object ``OPTIONAL`` in sequence
3017         """
3018         super(UTCTime, self).__init__(
3019             impl=impl,
3020             expl=expl,
3021             default=default,
3022             optional=optional,
3023             _decoded=_decoded,
3024         )
3025         self._value = value
3026         if value is not None:
3027             self._value = self._value_sanitize(value)
3028         if default is not None:
3029             default = self._value_sanitize(default)
3030             self.default = self.__class__(
3031                 value=default,
3032                 impl=self.tag,
3033                 expl=self._expl,
3034             )
3035             if self._value is None:
3036                 self._value = default
3037
3038     def _value_sanitize(self, value):
3039         if isinstance(value, self.__class__):
3040             return value._value
3041         if isinstance(value, datetime):
3042             return value.strftime(self.fmt).encode("ascii")
3043         if isinstance(value, binary_type):
3044             value_decoded = value.decode("ascii")
3045             if len(value_decoded) == LEN_YYMMDDHHMMSSZ:
3046                 try:
3047                     datetime.strptime(value_decoded, self.fmt)
3048                 except ValueError:
3049                     raise DecodeError("invalid UTCTime format")
3050                 return value
3051             else:
3052                 raise DecodeError("invalid UTCTime length")
3053         raise InvalidValueType((self.__class__, datetime))
3054
3055     def __eq__(self, their):
3056         if isinstance(their, binary_type):
3057             return self._value == their
3058         if isinstance(their, datetime):
3059             return self.todatetime() == their
3060         if not isinstance(their, self.__class__):
3061             return False
3062         return (
3063             self._value == their._value and
3064             self.tag == their.tag and
3065             self._expl == their._expl
3066         )
3067
3068     def todatetime(self):
3069         """Convert to datetime
3070
3071         :returns: datetime
3072
3073         Pay attention that UTCTime can not hold full year, so all years
3074         having < 50 years are treated as 20xx, 19xx otherwise, according
3075         to X.509 recomendation.
3076         """
3077         value = datetime.strptime(self._value.decode("ascii"), self.fmt)
3078         year = value.year % 100
3079         return datetime(
3080             year=(2000 + year) if year < 50 else (1900 + year),
3081             month=value.month,
3082             day=value.day,
3083             hour=value.hour,
3084             minute=value.minute,
3085             second=value.second,
3086         )
3087
3088     def __repr__(self):
3089         return pp_console_row(next(self.pps()))
3090
3091     def pps(self, decode_path=()):
3092         yield _pp(
3093             asn1_type_name=self.asn1_type_name,
3094             obj_name=self.__class__.__name__,
3095             decode_path=decode_path,
3096             value=self.todatetime().isoformat() if self.ready else None,
3097             optional=self.optional,
3098             default=self == self.default,
3099             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
3100             expl=None if self._expl is None else tag_decode(self._expl),
3101             offset=self.offset,
3102             tlen=self.tlen,
3103             llen=self.llen,
3104             vlen=self.vlen,
3105         )
3106
3107
3108 class GeneralizedTime(UTCTime):
3109     """``GeneralizedTime`` datetime type
3110
3111     This type is similar to :py:class:`pyderasn.UTCTime`.
3112
3113     >>> t = GeneralizedTime(datetime(2017, 9, 30, 22, 7, 50, 123))
3114     GeneralizedTime GeneralizedTime 2017-09-30T22:07:50.000123
3115     >>> str(t)
3116     '20170930220750.000123Z'
3117     >>> t = GeneralizedTime(datetime(2057, 9, 30, 22, 7, 50))
3118     GeneralizedTime GeneralizedTime 2057-09-30T22:07:50
3119     """
3120     __slots__ = ()
3121     tag_default = tag_encode(24)
3122     asn1_type_name = "GeneralizedTime"
3123
3124     fmt = "%Y%m%d%H%M%SZ"
3125     fmt_ms = "%Y%m%d%H%M%S.%fZ"
3126
3127     def _value_sanitize(self, value):
3128         if isinstance(value, self.__class__):
3129             return value._value
3130         if isinstance(value, datetime):
3131             return value.strftime(
3132                 self.fmt_ms if value.microsecond > 0 else self.fmt
3133             ).encode("ascii")
3134         if isinstance(value, binary_type):
3135             value_decoded = value.decode("ascii")
3136             if len(value_decoded) == LEN_YYYYMMDDHHMMSSZ:
3137                 try:
3138                     datetime.strptime(value_decoded, self.fmt)
3139                 except ValueError:
3140                     raise DecodeError(
3141                         "invalid GeneralizedTime (without ms) format",
3142                     )
3143                 return value
3144             elif len(value_decoded) >= LEN_YYYYMMDDHHMMSSDMZ:
3145                 try:
3146                     datetime.strptime(value_decoded, self.fmt_ms)
3147                 except ValueError:
3148                     raise DecodeError(
3149                         "invalid GeneralizedTime (with ms) format",
3150                     )
3151                 return value
3152             else:
3153                 raise DecodeError(
3154                     "invalid GeneralizedTime length",
3155                     klass=self.__class__,
3156                 )
3157         raise InvalidValueType((self.__class__, datetime))
3158
3159     def todatetime(self):
3160         value = self._value.decode("ascii")
3161         if len(value) == LEN_YYYYMMDDHHMMSSZ:
3162             return datetime.strptime(value, self.fmt)
3163         return datetime.strptime(value, self.fmt_ms)
3164
3165
3166 class GraphicString(CommonString):
3167     __slots__ = ()
3168     tag_default = tag_encode(25)
3169     encoding = "iso-8859-1"
3170     asn1_type_name = "GraphicString"
3171
3172
3173 class VisibleString(CommonString):
3174     __slots__ = ()
3175     tag_default = tag_encode(26)
3176     encoding = "ascii"
3177     asn1_type_name = "VisibleString"
3178
3179
3180 class ISO646String(VisibleString):
3181     __slots__ = ()
3182     asn1_type_name = "ISO646String"
3183
3184
3185 class GeneralString(CommonString):
3186     __slots__ = ()
3187     tag_default = tag_encode(27)
3188     encoding = "iso-8859-1"
3189     asn1_type_name = "GeneralString"
3190
3191
3192 class UniversalString(CommonString):
3193     __slots__ = ()
3194     tag_default = tag_encode(28)
3195     encoding = "utf-32-be"
3196     asn1_type_name = "UniversalString"
3197
3198
3199 class BMPString(CommonString):
3200     __slots__ = ()
3201     tag_default = tag_encode(30)
3202     encoding = "utf-16-be"
3203     asn1_type_name = "BMPString"
3204
3205
3206 class Choice(Obj):
3207     """``CHOICE`` special type
3208
3209     ::
3210
3211         class GeneralName(Choice):
3212             schema = (
3213                 ('rfc822Name', IA5String(impl=tag_ctxp(1))),
3214                 ('dNSName', IA5String(impl=tag_ctxp(2))),
3215             )
3216
3217     >>> gn = GeneralName()
3218     GeneralName CHOICE
3219     >>> gn["rfc822Name"] = IA5String("foo@bar.baz")
3220     GeneralName CHOICE rfc822Name[[1] IA5String IA5 foo@bar.baz]
3221     >>> gn["dNSName"] = IA5String("bar.baz")
3222     GeneralName CHOICE dNSName[[2] IA5String IA5 bar.baz]
3223     >>> gn["rfc822Name"]
3224     None
3225     >>> gn["dNSName"]
3226     [2] IA5String IA5 bar.baz
3227     >>> gn.choice
3228     'dNSName'
3229     >>> gn.value == gn["dNSName"]
3230     True
3231     >>> gn.specs
3232     OrderedDict([('rfc822Name', [1] IA5String IA5), ('dNSName', [2] IA5String IA5)])
3233
3234     >>> GeneralName(("rfc822Name", IA5String("foo@bar.baz")))
3235     GeneralName CHOICE rfc822Name[[1] IA5String IA5 foo@bar.baz]
3236     """
3237     __slots__ = ("specs",)
3238     tag_default = None
3239     asn1_type_name = "CHOICE"
3240
3241     def __init__(
3242             self,
3243             value=None,
3244             schema=None,
3245             impl=None,
3246             expl=None,
3247             default=None,
3248             optional=False,
3249             _decoded=(0, 0, 0),
3250     ):
3251         """
3252         :param value: set the value. Either ``(choice, value)`` tuple, or
3253                       :py:class:`pyderasn.Choice` object
3254         :param bytes impl: can not be set, do **not** use it
3255         :param bytes expl: override default tag with ``EXPLICIT`` one
3256         :param default: set default value. Type same as in ``value``
3257         :param bool optional: is object ``OPTIONAL`` in sequence
3258         """
3259         if impl is not None:
3260             raise ValueError("no implicit tag allowed for CHOICE")
3261         super(Choice, self).__init__(None, expl, default, optional, _decoded)
3262         if schema is None:
3263             schema = getattr(self, "schema", ())
3264         if len(schema) == 0:
3265             raise ValueError("schema must be specified")
3266         self.specs = (
3267             schema if isinstance(schema, OrderedDict) else OrderedDict(schema)
3268         )
3269         self._value = None
3270         if value is not None:
3271             self._value = self._value_sanitize(value)
3272         if default is not None:
3273             default_value = self._value_sanitize(default)
3274             default_obj = self.__class__(impl=self.tag, expl=self._expl)
3275             default_obj.specs = self.specs
3276             default_obj._value = default_value
3277             self.default = default_obj
3278             if value is None:
3279                 self._value = default_obj.copy()._value
3280
3281     def _value_sanitize(self, value):
3282         if isinstance(value, self.__class__):
3283             return value._value
3284         if isinstance(value, tuple) and len(value) == 2:
3285             choice, obj = value
3286             spec = self.specs.get(choice)
3287             if spec is None:
3288                 raise ObjUnknown(choice)
3289             if not isinstance(obj, spec.__class__):
3290                 raise InvalidValueType((spec,))
3291             return (choice, spec(obj))
3292         raise InvalidValueType((self.__class__, tuple))
3293
3294     @property
3295     def ready(self):
3296         return self._value is not None and self._value[1].ready
3297
3298     def copy(self):
3299         obj = self.__class__(schema=self.specs)
3300         obj._expl = self._expl
3301         obj.default = self.default
3302         obj.optional = self.optional
3303         obj.offset = self.offset
3304         obj.llen = self.llen
3305         obj.vlen = self.vlen
3306         value = self._value
3307         if value is not None:
3308             obj._value = (value[0], value[1].copy())
3309         return obj
3310
3311     def __eq__(self, their):
3312         if isinstance(their, tuple) and len(their) == 2:
3313             return self._value == their
3314         if not isinstance(their, self.__class__):
3315             return False
3316         return (
3317             self.specs == their.specs and
3318             self._value == their._value
3319         )
3320
3321     def __call__(
3322             self,
3323             value=None,
3324             expl=None,
3325             default=None,
3326             optional=None,
3327     ):
3328         return self.__class__(
3329             value=value,
3330             schema=self.specs,
3331             expl=self._expl if expl is None else expl,
3332             default=self.default if default is None else default,
3333             optional=self.optional if optional is None else optional,
3334         )
3335
3336     @property
3337     def choice(self):
3338         self._assert_ready()
3339         return self._value[0]
3340
3341     @property
3342     def value(self):
3343         self._assert_ready()
3344         return self._value[1]
3345
3346     def __getitem__(self, key):
3347         if key not in self.specs:
3348             raise ObjUnknown(key)
3349         if self._value is None:
3350             return None
3351         choice, value = self._value
3352         if choice != key:
3353             return None
3354         return value
3355
3356     def __setitem__(self, key, value):
3357         spec = self.specs.get(key)
3358         if spec is None:
3359             raise ObjUnknown(key)
3360         if not isinstance(value, spec.__class__):
3361             raise InvalidValueType((spec.__class__,))
3362         self._value = (key, spec(value))
3363
3364     @property
3365     def tlen(self):
3366         return 0
3367
3368     @property
3369     def decoded(self):
3370         return self._value[1].decoded if self.ready else False
3371
3372     def _encode(self):
3373         self._assert_ready()
3374         return self._value[1].encode()
3375
3376     def _decode(self, tlv, offset, decode_path, ctx):
3377         for choice, spec in self.specs.items():
3378             try:
3379                 value, tail = spec.decode(
3380                     tlv,
3381                     offset=offset,
3382                     leavemm=True,
3383                     decode_path=decode_path + (choice,),
3384                     ctx=ctx,
3385                 )
3386             except TagMismatch:
3387                 continue
3388             obj = self.__class__(
3389                 schema=self.specs,
3390                 expl=self._expl,
3391                 default=self.default,
3392                 optional=self.optional,
3393                 _decoded=(offset, 0, value.tlvlen),
3394             )
3395             obj._value = (choice, value)
3396             return obj, tail
3397         raise TagMismatch(
3398             klass=self.__class__,
3399             decode_path=decode_path,
3400             offset=offset,
3401         )
3402
3403     def __repr__(self):
3404         value = pp_console_row(next(self.pps()))
3405         if self.ready:
3406             value = "%s[%r]" % (value, self.value)
3407         return value
3408
3409     def pps(self, decode_path=()):
3410         yield _pp(
3411             asn1_type_name=self.asn1_type_name,
3412             obj_name=self.__class__.__name__,
3413             decode_path=decode_path,
3414             value=self.choice if self.ready else None,
3415             optional=self.optional,
3416             default=self == self.default,
3417             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
3418             expl=None if self._expl is None else tag_decode(self._expl),
3419             offset=self.offset,
3420             tlen=self.tlen,
3421             llen=self.llen,
3422             vlen=self.vlen,
3423         )
3424         if self.ready:
3425             yield self.value.pps(decode_path=decode_path + (self.choice,))
3426
3427
3428 class PrimitiveTypes(Choice):
3429     """Predefined ``CHOICE`` for all generic primitive types
3430
3431     It could be useful for general decoding of some unspecified values:
3432
3433     >>> PrimitiveTypes().decode(hexdec("0403666f6f"))[0].value
3434     OCTET STRING 3 bytes 666f6f
3435     >>> PrimitiveTypes().decode(hexdec("0203123456"))[0].value
3436     INTEGER 1193046
3437     """
3438     __slots__ = ()
3439     schema = tuple((klass.__name__, klass()) for klass in (
3440         Boolean,
3441         Integer,
3442         BitString,
3443         OctetString,
3444         Null,
3445         ObjectIdentifier,
3446         UTF8String,
3447         NumericString,
3448         PrintableString,
3449         TeletexString,
3450         VideotexString,
3451         IA5String,
3452         UTCTime,
3453         GeneralizedTime,
3454         GraphicString,
3455         VisibleString,
3456         ISO646String,
3457         GeneralString,
3458         UniversalString,
3459         BMPString,
3460     ))
3461
3462
3463 class Any(Obj):
3464     """``ANY`` special type
3465
3466     >>> Any(Integer(-123))
3467     ANY 020185
3468     >>> a = Any(OctetString(b"hello world").encode())
3469     ANY 040b68656c6c6f20776f726c64
3470     >>> hexenc(bytes(a))
3471     b'0x040x0bhello world'
3472     """
3473     __slots__ = ("defined",)
3474     tag_default = tag_encode(0)
3475     asn1_type_name = "ANY"
3476
3477     def __init__(
3478             self,
3479             value=None,
3480             expl=None,
3481             optional=False,
3482             _decoded=(0, 0, 0),
3483     ):
3484         """
3485         :param value: set the value. Either any kind of pyderasn's
3486                       **ready** object, or bytes. Pay attention that
3487                       **no** validation is performed is raw binary value
3488                       is valid TLV
3489         :param bytes expl: override default tag with ``EXPLICIT`` one
3490         :param bool optional: is object ``OPTIONAL`` in sequence
3491         """
3492         super(Any, self).__init__(None, expl, None, optional, _decoded)
3493         self._value = None if value is None else self._value_sanitize(value)
3494         self.defined = None
3495
3496     def _value_sanitize(self, value):
3497         if isinstance(value, self.__class__):
3498             return value._value
3499         if isinstance(value, Obj):
3500             return value.encode()
3501         if isinstance(value, binary_type):
3502             return value
3503         raise InvalidValueType((self.__class__, Obj, binary_type))
3504
3505     @property
3506     def ready(self):
3507         return self._value is not None
3508
3509     def copy(self):
3510         obj = self.__class__()
3511         obj._value = self._value
3512         obj.tag = self.tag
3513         obj._expl = self._expl
3514         obj.optional = self.optional
3515         obj.offset = self.offset
3516         obj.llen = self.llen
3517         obj.vlen = self.vlen
3518         return obj
3519
3520     def __eq__(self, their):
3521         if isinstance(their, binary_type):
3522             return self._value == their
3523         if issubclass(their.__class__, Any):
3524             return self._value == their._value
3525         return False
3526
3527     def __call__(
3528             self,
3529             value=None,
3530             expl=None,
3531             optional=None,
3532     ):
3533         return self.__class__(
3534             value=value,
3535             expl=self._expl if expl is None else expl,
3536             optional=self.optional if optional is None else optional,
3537         )
3538
3539     def __bytes__(self):
3540         self._assert_ready()
3541         return self._value
3542
3543     @property
3544     def tlen(self):
3545         return 0
3546
3547     def _encode(self):
3548         self._assert_ready()
3549         return self._value
3550
3551     def _decode(self, tlv, offset, decode_path, ctx):
3552         try:
3553             t, tlen, lv = tag_strip(tlv)
3554             l, llen, v = len_decode(lv)
3555         except DecodeError as err:
3556             raise err.__class__(
3557                 msg=err.msg,
3558                 klass=self.__class__,
3559                 decode_path=decode_path,
3560                 offset=offset,
3561             )
3562         if l > len(v):
3563             raise NotEnoughData(
3564                 "encoded length is longer than data",
3565                 klass=self.__class__,
3566                 decode_path=decode_path,
3567                 offset=offset,
3568             )
3569         tlvlen = tlen + llen + l
3570         v, tail = tlv[:tlvlen], v[l:]
3571         obj = self.__class__(
3572             value=v.tobytes(),
3573             expl=self._expl,
3574             optional=self.optional,
3575             _decoded=(offset, 0, tlvlen),
3576         )
3577         obj.tag = t
3578         return obj, tail
3579
3580     def __repr__(self):
3581         return pp_console_row(next(self.pps()))
3582
3583     def pps(self, decode_path=()):
3584         yield _pp(
3585             asn1_type_name=self.asn1_type_name,
3586             obj_name=self.__class__.__name__,
3587             decode_path=decode_path,
3588             blob=self._value if self.ready else None,
3589             optional=self.optional,
3590             default=self == self.default,
3591             impl=None if self.tag == self.tag_default else tag_decode(self.tag),
3592             expl=None if self._expl is None else tag_decode(self._expl),
3593             offset=self.offset,
3594             tlen=self.tlen,
3595             llen=self.llen,
3596             vlen=self.vlen,
3597             expl_offset=self.expl_offset if self.expled else None,
3598             expl_tlen=self.expl_tlen if self.expled else None,
3599             expl_llen=self.expl_llen if self.expled else None,
3600             expl_vlen=self.expl_vlen if self.expled else None,
3601         )
3602         defined_by, defined = self.defined or (None, None)
3603         if defined_by is not None:
3604             yield defined.pps(
3605                 decode_path=decode_path + (DecodePathDefBy(defined_by),)
3606             )
3607
3608
3609 ########################################################################
3610 # ASN.1 constructed types
3611 ########################################################################
3612
3613 def get_def_by_path(defines_by_path, sub_decode_path):
3614     """Get define by decode path
3615     """
3616     for path, define in defines_by_path:
3617         if len(path) != len(sub_decode_path):
3618             continue
3619         for p1, p2 in zip(path, sub_decode_path):
3620             if (p1 != any) and (p1 != p2):
3621                 break
3622         else:
3623             return define
3624
3625
3626 def abs_decode_path(decode_path, rel_path):
3627     """Create an absolute decode path from current and relative ones
3628
3629     :param decode_path: current decode path, starting point.
3630                         Tuple of strings
3631     :param rel_path: relative path to ``decode_path``. Tuple of strings.
3632                      If first tuple's element is "/", then treat it as
3633                      an absolute path, ignoring ``decode_path`` as
3634                      starting point. Also this tuple can contain ".."
3635                      elements, stripping the leading element from
3636                      ``decode_path``
3637
3638     >>> abs_decode_path(("foo", "bar"), ("baz", "whatever"))
3639     ("foo", "bar", "baz", "whatever")
3640     >>> abs_decode_path(("foo", "bar", "baz"), ("..", "..", "whatever"))
3641     ("foo", "whatever")
3642     >>> abs_decode_path(("foo", "bar"), ("/", "baz", "whatever"))
3643     ("baz", "whatever")
3644     """
3645     if rel_path[0] == "/":
3646         return rel_path[1:]
3647     if rel_path[0] == "..":
3648         return abs_decode_path(decode_path[:-1], rel_path[1:])
3649     return decode_path + rel_path
3650
3651
3652 class Sequence(Obj):
3653     """``SEQUENCE`` structure type
3654
3655     You have to make specification of sequence::
3656
3657         class Extension(Sequence):
3658             schema = (
3659                 ("extnID", ObjectIdentifier()),
3660                 ("critical", Boolean(default=False)),
3661                 ("extnValue", OctetString()),
3662             )
3663
3664     Then, you can work with it as with dictionary.
3665
3666     >>> ext = Extension()
3667     >>> Extension().specs
3668     OrderedDict([
3669         ('extnID', OBJECT IDENTIFIER),
3670         ('critical', BOOLEAN False OPTIONAL DEFAULT),
3671         ('extnValue', OCTET STRING),
3672     ])
3673     >>> ext["extnID"] = "1.2.3"
3674     Traceback (most recent call last):
3675     pyderasn.InvalidValueType: invalid value type, expected: <class 'pyderasn.ObjectIdentifier'>
3676     >>> ext["extnID"] = ObjectIdentifier("1.2.3")
3677
3678     You can know if sequence is ready to be encoded:
3679
3680     >>> ext.ready
3681     False
3682     >>> ext.encode()
3683     Traceback (most recent call last):
3684     pyderasn.ObjNotReady: object is not ready: extnValue
3685     >>> ext["extnValue"] = OctetString(b"foobar")
3686     >>> ext.ready
3687     True
3688
3689     Value you want to assign, must have the same **type** as in
3690     corresponding specification, but it can have different tags,
3691     optional/default attributes -- they will be taken from specification
3692     automatically::
3693
3694         class TBSCertificate(Sequence):
3695             schema = (
3696                 ("version", Version(expl=tag_ctxc(0), default="v1")),
3697             [...]
3698
3699     >>> tbs = TBSCertificate()
3700     >>> tbs["version"] = Version("v2") # no need to explicitly add ``expl``
3701
3702     Assign ``None`` to remove value from sequence.
3703
3704     You can know if value exists/set in the sequence and take its value:
3705
3706     >>> "extnID" in ext, "extnValue" in ext, "critical" in ext
3707     (True, True, False)
3708     >>> ext["extnID"]
3709     OBJECT IDENTIFIER 1.2.3
3710
3711     But pay attention that if value has default, then it won't be (not
3712     in) in the sequence (because ``DEFAULT`` must not be encoded in
3713     DER), but you can read its value:
3714
3715     >>> "critical" in ext, ext["critical"]
3716     (False, BOOLEAN False)
3717     >>> ext["critical"] = Boolean(True)
3718     >>> "critical" in ext, ext["critical"]
3719     (True, BOOLEAN True)
3720
3721     All defaulted values are always optional.
3722
3723     .. _strict_default_existence_ctx:
3724
3725     .. warning::
3726
3727        When decoded DER contains defaulted value inside, then
3728        technically this is not valid DER encoding. But we allow and pass
3729        it **by default**. Of course reencoding of that kind of DER will
3730        result in different binary representation (validly without
3731        defaulted value inside). You can enable strict defaulted values
3732        existence validation by setting ``"strict_default_existence":
3733        True`` :ref:`context <ctx>` option -- decoding process will raise
3734        an exception if defaulted value is met.
3735
3736     Two sequences are equal if they have equal specification (schema),
3737     implicit/explicit tagging and the same values.
3738     """
3739     __slots__ = ("specs",)
3740     tag_default = tag_encode(form=TagFormConstructed, num=16)
3741     asn1_type_name = "SEQUENCE"
3742
3743     def __init__(
3744             self,
3745             value=None,
3746             schema=None,
3747             impl=None,
3748             expl=None,
3749             default=None,
3750             optional=False,
3751             _decoded=(0, 0, 0),
3752     ):
3753         super(Sequence, self).__init__(impl, expl, default, optional, _decoded)
3754         if schema is None:
3755             schema = getattr(self, "schema", ())
3756         self.specs = (
3757             schema if isinstance(schema, OrderedDict) else OrderedDict(schema)
3758         )
3759         self._value = {}
3760         if value is not None:
3761             self._value = self._value_sanitize(value)
3762         if default is not None:
3763             default_value = self._value_sanitize(default)
3764             default_obj = self.__class__(impl=self.tag, expl=self._expl)
3765             default_obj.specs = self.specs
3766             default_obj._value = default_value
3767             self.default = default_obj
3768             if value is None:
3769                 self._value = default_obj.copy()._value
3770
3771     def _value_sanitize(self, value):
3772         if not issubclass(value.__class__, Sequence):
3773             raise InvalidValueType((Sequence,))
3774         return value._value
3775
3776     @property
3777     def ready(self):
3778         for name, spec in self.specs.items():
3779             value = self._value.get(name)
3780             if value is None:
3781                 if spec.optional:
3782                     continue
3783                 return False