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