HEX

File: //var/opt/nydus/ops/asn1crypto/__pycache__/core.cpython-39.pyc
a

�,�hܚ�@s�dZddlmZmZmZmZddlmZmZddlm	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlmZddlmZdd	lmZdd
lmZmZmZmZmZddlmZmZddlmZm Z m!Z!m"Z"m#Z#m$Z$ej%d
kr�ddl&m'Z(e)Z*dZ+nddl,m(Z(dZ+e�-�ddddd�Z.ddddddddd�Z/ddd�Z0e
�1d�Z2iZ3d�dd�Z4Gd d!�d!e5�Z6Gd"d#�d#�Z7Gd$d%�d%e5�Z8Gd&d'�d'e5�Z9Gd(d)�d)e6�Z:e:�Z;Gd*d+�d+e6�Z<Gd,d-�d-e6�Z=Gd.d/�d/e5�Z>Gd0d1�d1e6�Z?Gd2d3�d3e9e?�Z@Gd4d5�d5e?�ZAGd6d7�d7e?e7�ZBGd8d9�d9e5�ZCGd:d;�d;eCe9e8e?e7�ZDGd<d=�d=e9e8e?�ZEGd>d?�d?eCe9e8e?�ZFGd@dA�dAe9e8e?�ZGGdBdC�dCe9e8e?�ZHGdDdE�dEe9e8e?�ZIGdFdG�dGeI�ZJGdHdI�dIe?�ZKGdJdK�dKe?e7�ZLGdLdM�dMe?�ZMGdNdO�dOe?�ZNGdPdQ�dQe?�ZOGdRdS�dSeB�ZPGdTdU�dUe@�ZQGdVdW�dWeL�ZRGdXdY�dYe6�ZSGdZd[�d[e6�ZTGd\d]�d]eS�ZUGd^d_�d_eT�ZVGd`da�daeS�ZWGdbdc�dce@�ZXGddde�dee@�ZYGdfdg�dge@�ZZGdhdi�dieG�Z[Gdjdk�dke@�Z\Gdldm�dme@�Z]Gdndo�doe]�Z^Gdpdq�dqe]�Z_Gdrds�dse@�Z`Gdtdu�due@�ZaGdvdw�dwe@�ZbGdxdy�dye@�ZcGdzd{�d{e@�ZdGd|d}�d}e@�Zed~d�Zfd�d��Zgd�d��Zhd�d��Zid�d��ZjeAeBeDeGeKeLeMeNeOePeWeQeReSeUeXeYeZe[e\e^e_e`eaebecedeed��Zkd�d�d��Zld�d�d��ZmdS)�a
ASN.1 type classes for universal types. Exports the following items:

 - load()
 - Any()
 - Asn1Value()
 - BitString()
 - BMPString()
 - Boolean()
 - CharacterString()
 - Choice()
 - EmbeddedPdv()
 - Enumerated()
 - GeneralizedTime()
 - GeneralString()
 - GraphicString()
 - IA5String()
 - InstanceOf()
 - Integer()
 - IntegerBitString()
 - IntegerOctetString()
 - Null()
 - NumericString()
 - ObjectDescriptor()
 - ObjectIdentifier()
 - OctetBitString()
 - OctetString()
 - PrintableString()
 - Real()
 - RelativeOid()
 - Sequence()
 - SequenceOf()
 - Set()
 - SetOf()
 - TeletexString()
 - UniversalString()
 - UTCTime()
 - UTF8String()
 - VideotexString()
 - VisibleString()
 - VOID
 - Void()

Other type classes are defined that help compose the types listed above.
�)�unicode_literals�division�absolute_import�print_function)�datetime�	timedelta)�FractionN�)�_teletex_codec)�unwrap)�OrderedDict)�	type_name�str_cls�byte_cls�	int_types�chr_cls)�_parse�_dump_header)�int_to_bytes�int_from_bytes�timezone�extended_datetime�create_timezone�utc_with_dst)�)�StringIOT)�BytesIOF�	universal�application�context�private)rr	�rr!r)rrrr rr	r!r�	primitive�constructed�rr	z
^\d+(\.\d+)*$cCstj||d�S)a5
    Loads a BER/DER-encoded byte string and construct a universal object based
    on the tag value:

     - 1: Boolean
     - 2: Integer
     - 3: BitString
     - 4: OctetString
     - 5: Null
     - 6: ObjectIdentifier
     - 7: ObjectDescriptor
     - 8: InstanceOf
     - 9: Real
     - 10: Enumerated
     - 11: EmbeddedPdv
     - 12: UTF8String
     - 13: RelativeOid
     - 16: Sequence,
     - 17: Set
     - 18: NumericString
     - 19: PrintableString
     - 20: TeletexString
     - 21: VideotexString
     - 22: IA5String
     - 23: UTCTime
     - 24: GeneralizedTime
     - 25: GraphicString
     - 26: VisibleString
     - 27: GeneralString
     - 28: UniversalString
     - 29: CharacterString
     - 30: BMPString

    :param encoded_data:
        A byte string of BER or DER-encoded data

    :param strict:
        A boolean indicating if trailing data should be forbidden - if so, a
        ValueError will be raised when trailing data exists

    :raises:
        ValueError - when strict is True and trailing data is present
        ValueError - when the encoded value tag a tag other than listed above
        ValueError - when the ASN.1 header length is longer than the data
        TypeError - when encoded_data is not a byte string

    :return:
        An instance of the one of the universal classes
    )�strict)�	Asn1Value�load)�encoded_datar%�r)�@/opt/nydus/tmp/pip-target-wkfpz8uv/lib/python/asn1crypto/core.pyr'ss3r'c
@s�eZdZdZdZdZdZdZdZdZ	dZ
dZdZdZ
ed$dd��Zd%dd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zd&dd�Zdd�Zdd�Zd'd d!�Zd(d"d#�ZdS))r&z'
    The basis of all ASN.1 values
    NF�cKsDt|t�stdt|���d}|jdur,|}t||||d�\}}|S)a�
        Loads a BER/DER-encoded byte string using the current class as the spec

        :param encoded_data:
            A byte string of BER or DER-encoded data

        :param strict:
            A boolean indicating if trailing data should be forbidden - if so, a
            ValueError will be raised when trailing data exists

        :return:
            An instance of the current class
        �*encoded_data must be a byte string, not %sN��spec�spec_paramsr%)�
isinstancer�	TypeErrorr
�tag�_parse_build)�clsr(r%�kwargsr.�value�_r)r)r*r'�s

zAsn1Value.loadc
Cs��z4|jtvrR|j}|jdur8t|jdt�r8|jf|_t|d�rJ|��dt|<|dur�t|t�rx|durpd}||f}|dkr�d}d}|dur�t|t�r�|dur�d}||f}|dkr�d}d}|du�r
|dur�d}|dkr�||f}n$|dkr�||f}nttdt	|����|du�r�t
|�d	k�r8t|d
t��r8|f}|D]�\}}d}t|t��rd|tv�rz|}n|tv�rr|}t|}|du�r�ttdt	|����|du�r�t|t��s�t
tdt|����|jdu�r�||ff|_n|j||ff|_�q<n�|du�r^|\}}|tv�rttd
t	|����|du�rFt|t��sFt
tdt|����t||_||_d|_nR|du�r�|tv�r�ttdt	|����t||_|jdu�r�d|_|du�r�||_|
du�r|
tgd��v�r�ttdt	|
����|
dk�r�d}
n|
dk�r�d
}
|
|_|�rd|_|	du�r |	|_n|du�r4|�|�WnZtt
f�y�}
z<|
jd
d�}|
jddt|�f||
_|
�WYd}
~
n
d}
~
00dS)a�
        The optional parameter is not used, but rather included so we don't
        have to delete it from the parameter dictionary when passing as keyword
        args

        :param explicit:
            An int tag number for explicit tagging, or a 2-element tuple of
            class and tag.

        :param implicit:
            An int tag number for implicit tagging, or a 2-element tuple of
            class and tag.

        :param no_explicit:
            If explicit tagging info should be removed from this instance.
            Used internally to allow contructing the underlying value that
            has been wrapped in an explicit tag.

        :param tag_type:
            None for normal values, or one of "implicit", "explicit" for tagged
            values. Deprecated in favor of explicit and implicit params.

        :param class_:
            The class for the value - defaults to "universal" if tag_type is
            None, otherwise defaults to "context". Valid values include:
             - "universal"
             - "application"
             - "context"
             - "private"
            Deprecated in favor of explicit and implicit params.

        :param tag:
            The integer tag to override - usually this is used with tag_type or
            class_. Deprecated in favor of explicit and implicit params.

        :param optional:
            Dummy parameter that allows "optional" key in spec param dicts

        :param default:
            The default value to use if the value is currently None

        :param contents:
            A byte string of the encoded contents of the value

        :param method:
            The method for the value - no default value since this is
            normally set on a class. Valid values include:
             - "primitive" or 0
             - "constructed" or 1

        :raises:
            ValueError - when implicit, explicit, tag_type, class_ or tag are invalid values
        Nr�_setupTr�explicit�implicitzh
                        tag_type must be one of "implicit", "explicit", not %s
                        r!r	z�
                            explicit class must be one of "universal", "application",
                            "context", "private", not %s
                            zi
                                explicit tag must be an integer, not %s
                                z�
                        implicit class must be one of "universal", "application",
                        "context", "private", not %s
                        za
                            implicit tag must be an integer, not %s
                            z�
                            class_ must be one of "universal", "application",
                            "context", "private", not %s
                            )r"rr#r	z�
                        method must be one of "primitive" or "constructed",
                        not %s
                        r"r#�
    while constructing %s)�	__class__�_SETUP_CLASSESr9r0r�hasattrr8�
ValueErrorr�repr�len�CLASS_NUM_TO_NAME_MAP�CLASS_NAME_TO_NUM_MAPr1r
�class_r2r:�set�method�contents�args)�selfr9r:�no_explicit�tag_typerDr2�optional�defaultrGrFr4Z
invalid_class�erHr)r)r*�__init__�s�8







�



�
�

�
�


�


�



zAsn1Value.__init__cCstr|��S|��SdS�z�
        Since str is different in Python 2 and 3, this calls the appropriate
        method, __unicode__() or __bytes__()

        :return:
            A unicode string
        N��_PY2�	__bytes__�__unicode__�rIr)r)r*�__str__�s	zAsn1Value.__str__cCsDtr"dt|�t|�t|���fSdt|�t|�t|���fSdS)�7
        :return:
            A unicode string
        z<%s %s b%s>�
<%s %s %s>N)rRr
�idr@�dumprUr)r)r*�__repr__�szAsn1Value.__repr__cCs|���d�S)z�
        A fall-back method for print() in Python 2

        :return:
            A byte string of the output of repr()
        �utf-8)r[�encoderUr)r)r*rS�szAsn1Value.__bytes__cCs|��S)z�
        A fall-back method for print() in Python 3

        :return:
            A unicode string of the output of repr()
        )r[rUr)r)r*rT�szAsn1Value.__unicode__cCs,|��}|j|_|j|_|j|_|j|_|S)z�
        Constructs a new copy of the current object, preserving any tagging

        :return:
            An Asn1Value object
        )r<rDr2r:r9�rI�new_objr)r)r*�
_new_instance�szAsn1Value._new_instancecCs|��}|�|tj�|S)z�
        Implements the copy.copy() interface

        :return:
            A new shallow copy of the current Asn1Value object
        )r`�_copy�copyr^r)r)r*�__copy__�szAsn1Value.__copy__cCs&|��}||t|�<|�|tj�|S)z�
        Implements the copy.deepcopy() interface

        :param memo:
            A dict for memoization

        :return:
            A new deep copy of the current Asn1Value object
        )r`rYrarb�deepcopy�rI�memor_r)r)r*�__deepcopy__�szAsn1Value.__deepcopy__cCs
t�|�S)z}
        Copies the object, preserving any special tagging from it

        :return:
            An Asn1Value object
        �rbrdrUr)r)r*rbszAsn1Value.copycCs>t|t�s||i}|j|�d�|�d�d�}|�|tj�|S)a}
        Copies the object, applying a new tagging to it

        :param tagging:
            A dict containing the keys "explicit" and "implicit". Legacy
            API allows a unicode string of "implicit" or "explicit".

        :param tag:
            A integer tag number. Only used when tagging is a unicode string.

        :return:
            An Asn1Value object
        r9r:)r9r:)r0�dictr<�getrarbrd)rIZtaggingr2r_r)r)r*�retags

zAsn1Value.retagcCs|��}|�|tj�|S)z{
        Copies the object, removing any special tagging from it

        :return:
            An Asn1Value object
        )r<rarbrdr^r)r)r*�untag/szAsn1Value.untagcCs<|j|jkr$ttdt|�t|����|j|_||j�|_dS)a!
        Copies the contents of another Asn1Value object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        �Q
                Can not copy values from %s object to %s object
                N)r<r1rr
rG�_native�rI�other�	copy_funcr)r)r*ra;s�zAsn1Value._copyr	cCs�d|}t|d�}t||�|r2|j�|d�nVt|d�rN|j�|d�n:trvt|jt�rvt	d|t
|j�f�nt	d||jf�dS)�J
        Show the binary data and parsed data in a tree structure
        �  �parsedr!�chosenz%s    Native: b%sz%s    Native: %sN)r>�_basic_debugrt�debugrurRr0�nativer�printr@)rI�
nest_level�prefixZ
has_parsedr)r)r*rwSs


zAsn1Value.debugcCs�|j}|jdur&|jdd�dkr&d}|jdus4|r�t|t�rJ|jrJd|_t|j|j|j|j�}|j	dur�|j	D] \}}t|d|||j�|}qp||_d|_
|j||j
S)�
        Encodes the value using DER

        :param force:
            If the encoded contents already exist, clear them and regenerate
            to ensure they are in DER format instead of BER format

        :return:
            A byte string of the DER-encoded value
        N�����Trr	r+)rG�_headerr0�
Constructable�_indefiniterFrrDr2r9�_trailer)rI�forcerG�headerrDr2r)r)r*rZis
zAsn1Value.dump)F)
NNFNNNNNNN)N)r	)F)�__name__�
__module__�__qualname__�__doc__rFrDr2�_bad_tagr:r9rrGr�rn�classmethodr'rOrVr[rSrTr`rcrgrbrkrlrarwrZr)r)r)r*r&�s<�
O




r&c@s eZdZdZdZdZdd�ZdS)�ValueMapzl
    Basic functionality that allows for mapping values from ints or OIDs to
    python unicode strings
    NcCsF|j}|jdus|jdurdSi|_|j��D]\}}||j|<q.dS)�2
        Generates _reverse_map from _map
        N)r<�_map�_reverse_map�items)rIr4�keyr6r)r)r*r8�szValueMap._setup)r�r�r�r�r�r�r8r)r)r)r*r��sr�c@seZdZdZdd�ZdS)�Castablez�
    A mixin to handle converting an object between different classes that
    represent the same encoded value, but with different rules for converting
    to and from native Python values
    cCs�|j|jjkr0ttdt|�t|�|j|jj���|�}|j|_|j|_|j|_|j|_|j	|_	|j
|_
t|t�r�|j
|_
|j|_|S)a+
        Converts the current object into an object of a different class. The
        new class must use the ASN.1 encoding for the value.

        :param other_class:
            The class to instantiate the new object from

        :return:
            An instance of the type other_class
        z�
                Can not covert a value from %s object to %s object since they
                use different tags: %d versus %d
                )r2r<r1rr
rDr:r9rrGr�r0r�rFr�)rIZother_classr_r)r)r*�cast�s&�
z
Castable.castN)r�r�r�r�r�r)r)r)r*r��sr�cs<eZdZdZdZdd�Zdd�Zdd�Z�fd	d
�Z�Z	S)r�z�
    A mixin to handle string types that may be constructed from chunks
    contained within an indefinite length BER-encoded container
    FcCsr|js|��Sd}t|j�}d}||kr^t|j||jd�\}}|durP|��}q ||��7}q |durn|��S|S)zc
        :return:
            A concatenation of the native values of the contained chunks
        rN)r.)r��	_as_chunkrArGr3r<�
_merge_chunks)rI�pointer�contents_len�outputZ	sub_valuer)r)r*r��s

zConstructable._merge_chunkscCs|jS)a
        A method to return a chunk of data that can be combined for
        constructed method values

        :return:
            A native Python value that can be added together. Examples include
            byte strings, unicode strings or tuples.
        �rGrUr)r)r*r��s
zConstructable._as_chunkcCs|jS)a�
        Returns a native value that can be round-tripped into .set(), to
        result in a DER encoding. This differs from .native in that .native
        is designed for the end use, and may account for the fact that the
        merged value is further parsed as ASN.1, such as in the case of
        ParsableOctetString() and ParsableOctetBitString().

        :return:
            A python value that is valid to pass to .set()
        �rxrUr)r)r*�_setable_nativeszConstructable._setable_nativecs*tt|��||�|jr&|�|���dS)a%
        Copies the contents of another Constructable object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)�superr�rar�rEr�ro�r<r)r*raszConstructable._copy)
r�r�r�r�r�r�r�r�ra�
__classcell__r)r)r�r*r��sr�c@sJeZdZdZdZdd�Zdd�Zdd�Zd	d
�Ze	dd��Z
ddd�ZdS)�Voidz�
    A representation of an optional value that is not present. Has .native
    property and .dump() method to be compatible with other value classes.
    r+cCs|j|jkS)�u
        :param other:
            The other Primitive to compare to

        :return:
            A boolean
        r��rIrpr)r)r*�__eq__+s	zVoid.__eq__cCsdS)NFr)rUr)r)r*�__nonzero__6szVoid.__nonzero__cCsdS�Nrr)rUr)r)r*�__len__9szVoid.__len__cCstd�S)Nr))�iterrUr)r)r*�__iter__<sz
Void.__iter__cCsdS�zl
        The native Python datatype representation of this value

        :return:
            None
        Nr)rUr)r)r*rx?s	zVoid.nativeFcCsdS)r|r+r)�rIr�r)r)r*rZJsz	Void.dumpN)F)r�r�r�r�rGr�r�r�r��propertyrxrZr)r)r)r*r�#s

r�csZeZdZdZdZddd�Zedd��Zedd��Zdd	d
�Z	�fdd�Z
ddd�Z�ZS)�Anyz�
    A value class that can contain any value, and allows for easy parsing of
    the underlying encoded value using a spec. This is normally contained in
    a Structure that has an ObjectIdentifier field and _oid_pair and _oid_specs
    defined.
    Nc
Ks�tj|fi|��z@|durPt|t�s8ttdt|����||jdf|_|��|_	WnXt
tfy�}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00dS)z�
        Sets the value of the object before passing to Asn1Value.__init__()

        :param value:
            An Asn1Value object that will be set as the parsed value
        Nz`
                        value must be an instance of Asn1Value, not %s
                        r	rr;)r&rOr0r1rr
r<�_parsedrZrGr?rH)rIr6r5rNrHr)r)r*rOgs
�zAny.__init__cCs|jdur|��|jdjS)z�
        The native Python datatype representation of this value

        :return:
            The .native value from the parsed value object
        Nr)r��parserxrUr)r)r*rx�s	
z
Any.nativecCs|jdur|��|jdS�zw
        Returns the parsed object from .parse()

        :return:
            The object returned by .parse()
        Nr�r�r�rUr)r)r*rt�s	
z
Any.parsedc	
Cs |jdus"|jdd�||fk�rz�|p*i}t|�|jdurdd|vrZ|j|d|d<n
|j|d<|j|j|j}t|||d�\}}|||f|_d|_d|_d|_d|_||_d|_WnZt	t
f�y}z<|jdd�}|jdd	t|�f||_|�WYd}~n
d}~00|jdS)
�v
        Parses the contents generically, or using a spec with optional params

        :param spec:
            A class derived from Asn1Value that defines what class_ and tag the
            value should have, and the semantics of the encoded value. The
            return value will be of this type. If omitted, the encoded value
            will be decoded using the standard universal tag based on the
            encoded tag number.

        :param spec_params:
            A dict of params to pass to the spec object

        :return:
            An object of the type spec, or if not present, a child of Asn1Value
        Nr	rr9�r.r/Fr+r�
    while parsing %s)
r��_tag_type_to_explicit_implicitr9rrGr�r3r2r:r?r1rHr
)	rIr.r/Z
passed_paramsrG�parsed_valuer7rNrHr)r)r*r��s4"

�

z	Any.parsecs"tt|��||�||j�|_dS)a
        Copies the contents of another Any object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r�rar�ror�r)r*ra�sz	Any._copyFcCs$|jdur|��|jdj|d�S)r|Nr�r�)r�r�rZr�r)r)r*rZ�s
zAny.dump)N)NN)F)
r�r�r�r�r�rOr�rxrtr�rarZr�r)r)r�r*r�\s



2r�cs�eZdZdZdZdZdZdZdZdZ	dZ
eddd��Zdd�Z
ddd	�Zed
d��Zejdd��Zed
d��Zdd�Zedd��Zedd��Zdd�Zdd�Z�fdd�Zddd�Z�ZS) �ChoicezF
    A class to handle when a value may be one of several options
    NFcKs2t|t�stdt|���t||||d�\}}|S)a�
        Loads a BER/DER-encoded byte string using the current class as the spec

        :param encoded_data:
            A byte string of BER or DER encoded data

        :param strict:
            A boolean indicating if trailing data should be forbidden - if so, a
            ValueError will be raised when trailing data exists

        :return:
            A instance of the current class
        r,r-)r0rr1r
r3)r4r(r%r5r6r7r)r)r*r's
zChoice.loadcCst|j}i|_i|_t|j�D]R\}}t|�dkrD|if}||j|<t|d|d�}||j|<||j|d<qdS)zS
        Generates _id_map from _alternatives to allow validating contents
        rr!r	rN)r<�_id_map�	_name_map�	enumerate�
_alternativesrA�_build_id_tuple)rIr4�index�info�id_r)r)r*r8+s


z
Choice._setupc	
Ks�t|�tj|fi|���z|�d�dur8ttd���|du�r,t|t�r�t|�dkrpttdt	|�t|����t
|���d\}}t|t�r�t|�dkr�ttdt	|�t|����|d}|d}||j
vr�ttd	|t	|����|j
||_|j|j\}}}t||��s||fi|��}n
t||�}||_WnZttf�y�}z<|jdd�}|jdd
t	|�f||_|�WYd}~n
d}~00dS)aq
        Checks to ensure implicit tagging is not being used since it is
        incompatible with Choice, then forwards on to Asn1Value.__init__()

        :param name:
            The name of the alternative to be set - used with value.
            Alternatively this may be a dict with a single key being the name
            and the value being the value, or a two-element tuple of the name
            and the value.

        :param value:
            The alternative value to set - used with name

        :raises:
            ValueError - when implicit param is passed (or legacy tag_type param is "implicit")
        r:Nz�
                    The Choice type can not be implicitly tagged even if in an
                    implicit module - due to its nature any tagging must be
                    explicit
                    r	z�
                            When passing a dict as the "name" argument to %s,
                            it must have a single key/value - however %d were
                            present
                            rr!z�
                            When passing a tuple as the "name" argument to %s,
                            it must have two elements, the name and value -
                            however %d were present
                            z�
                        The name specified, "%s", is not a valid alternative
                        for %s
                        r;)r�r&rOrjr?rr0rirAr
�listr��tupler��_choicer��_fix_taggingr�r1rH)	rI�namer6r5r7r.�paramsrNrHr)r)r*rO;sR�

�	
�	
�	

zChoice.__init__cCs|jdur|jjS|jS)zj
        :return:
            A byte string of the DER-encoded contents of the chosen alternative
        N)r�rG�	_contentsrUr)r)r*rG�s
zChoice.contentscCs
||_dS)zo
        :param value:
            A byte string of the DER-encoded contents of the chosen alternative
        N�r��rIr6r)r)r*rG�scCs|js|j|jd|_|jS)zc
        :return:
            A unicode string of the field name of the chosen alternative
        r)�_namer�r�rUr)r)r*r��szChoice.namec
Cs�|jdur�z,|j|j\}}}t|j||d�\|_}WnXttfy�}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00|jS)z}
        Parses the detected alternative

        :return:
            An Asn1Value object of the chosen alternative
        Nr�r	rr�)	r�r�r�r3r�r?r1rHr
)rIr7r.r�rNrHr)r)r*r��s
zChoice.parsecCs|��S)zT
        :return:
            An Asn1Value object of the chosen alternative
        )r�rUr)r)r*ru�sz
Choice.chosencCs|jjS)z�
        The native Python datatype representation of this value

        :return:
            The .native value from the contained value object
        )rurxrUr)r)r*rx�s	z
Choice.nativecs||f}�jdurX�jd|kr2ttdt�����t|t|��\\}}}}}}}||f}|�jvrr�j|�_dS�jdur��j	dur�t�j
�dkr�ttdt�����|�j�j	fkr�d�_dS��||�}�fdd��jD�}ttd	|t��d
�|����dS)a�
        Ensures that the class and tag specified exist as an alternative

        :param class_:
            The integer class_ from the encoded value header

        :param tag:
            The integer tag from the encoded value header

        :param contents:
            A byte string of the contents of the value - used when the object
            is explicitly tagged

        :raises:
            ValueError - when value is not a valid alternative
        Nr}z�
                    %s was explicitly tagged, but the value provided does not
                    match the class and tag
                    r	z|
                    %s was implicitly tagged, but more than one alternative
                    exists
                    rcs g|]}��|d|d��qSr$)�_format_class_tag)�.0�pairrUr)r*�
<listcomp>r+z#Choice.validate.<locals>.<listcomp>zs
            Value %s did not match the class and tag of any of the alternatives
            in %s: %s
            �, )
r9r?rr
rrAr�r�rDr2r�r��join)rIrDr2rGr�r7Zasn1Zasn1sr)rUr*�validate�s:
�
��zChoice.validatecCsdt|��|fS)zo
        :return:
            A unicode string of a human-friendly representation of the class and tag
        z[%s %s])rB�upper)rIrDr2r)r)r*r�szChoice._format_class_tagcs2tt|��||�|j|_|j|_||j�|_dS)a
        Copies the contents of another Choice object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r�rar�r�r�ror�r)r*raszChoice._copycCs�|jdur |jdd�dkr d}|jj|d�|_|jdus>|r|d|_|jdur||jD]&\}}t|d||j|j�|j|_qT|j|jS)r|Nr}r~Tr�r+r	)rrurZr�r9r)rIr�rDr2r)r)r*rZ-s

 zChoice.dump)F)NN)F)r�r�r�r�r�r�r�r�r�r�r�r�r'r8rOr�rG�setterr�r�rurxr�r�rarZr�r)r)r�r*r��s6
T


	


@r�c@s�eZdZdZdZdZed'dd��Zd(dd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�Zdd�Zd)dd�Zd*dd�Zedd��Zdd �Zd!d"�Zd#d$�Zd%d&�ZdS)+�Concata
    A class that contains two or more encoded child values concatentated
    together. THIS IS NOT PART OF THE ASN.1 SPECIFICATION! This exists to handle
    the x509.TrustedCertificate() class for OpenSSL certificates containing
    extra information.
    NFcCs|||d�S)a�
        Loads a BER/DER-encoded byte string using the current class as the spec

        :param encoded_data:
            A byte string of BER or DER encoded data

        :param strict:
            A boolean indicating if trailing data should be forbidden - if so, a
            ValueError will be raised when trailing data exists

        :return:
            A Concat object
        )rGr%r))r4r(r%r)r)r*r'SszConcat.loadc

Cs|dur�zpt|�}g|_d}|jD]2}||krBt|||d�\}}n|�}|j�|�q"|rv||krv||}td|��WnXttfy�}	z<|	jdd�}
|	jddt|�f|
|	_|	�WYd}	~	n
d}	~	00|du�r|jdur�dgt|j�|_t	|�D]\}}|�
||��qdS)a
        :param value:
            A native Python datatype to initialize the object value with

        :param contents:
            A byte string of the encoded contents of the value

        :param strict:
            A boolean indicating if trailing data should be forbidden - if so, a
            ValueError will be raised when trailing data exists in contents

        :raises:
            ValueError - when an error occurs with one of the children
            TypeError - when an error occurs with one of the children
        Nr)r�r.�4Extra data - %d bytes of trailing data were providedr	r;)rA�	_children�_child_specsr3�appendr?r1rHr
r��__setitem__)
rIr6rGr%r��offsetr.Zchild_value�extra_bytesrNrHr��datar)r)r*rOes,


zConcat.__init__cCstr|��S|��SdSrPrQrUr)r)r*rV�s	zConcat.__str__cCs|��S)z;
        A byte string of the DER-encoded contents
        �rZrUr)r)r*rS�szConcat.__bytes__cCst|�S�rW)r@rUr)r)r*rT�szConcat.__unicode__cCsdt|�t|�t|���fS)rWrX)r
rYr@rZrUr)r)r*r[�szConcat.__repr__cCs|��}|�|tj�|S)z|
        Implements the copy.copy() interface

        :return:
            A new shallow copy of the Concat object
        )r<rarbr^r)r)r*rc�szConcat.__copy__cCs&|��}||t|�<|�|tj�|S)z�
        Implements the copy.deepcopy() interface

        :param memo:
            A dict for memoization

        :return:
            A new deep copy of the Concat object and all child objects
        )r<rYrarbrdrer)r)r*rg�szConcat.__deepcopy__cCs
t�|�S)zQ
        Copies the object

        :return:
            A Concat object
        rhrUr)r)r*rb�szConcat.copycCs4|j|jkr$ttdt|�t|����||j�|_dS)a
        Copies the contents of another Concat object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        rmN)r<r1rr
r�ror)r)r*ra�s�zConcat._copyr	cCsNd|}td|t|�t|�f�td|f�|jD]}|�|d�q6dS)rrrs�%s%s Object #%sz
%s  Children:r!N)ryr
rYr�rw�rIrzr{�childr)r)r*rw�s

zConcat.debugcCs$d}|jD]}||j|d�7}q
|S)r|r+r�)r�rZ�rIr�rGr�r)r)r*rZ�s
zConcat.dumpcCs|��S)z`
        :return:
            A byte string of the DER-encoded contents of the children
        r�rUr)r)r*rGszConcat.contentscCs
t|j�S)�.
        :return:
            Integer
        )rAr�rUr)r)r*r�szConcat.__len__cCs8|t|j�dks|dkr.ttd|t|����|j|S)z�
        Allows accessing children by index

        :param key:
            An integer of the child index

        :raises:
            KeyError - when an index is invalid

        :return:
            The Asn1Value object of the child specified
        r	rzN
                No child is definition for position %d of %s
                )rAr��KeyErrorrr
r��rIr�r)r)r*�__getitem__!s�zConcat.__getitem__cCsZ|t|j�dks|dkr.ttd|t|����t|t�sLttd|t|����||j|<dS)aG
        Allows settings children by index

        :param key:
            An integer of the child index

        :param value:
            An Asn1Value object to set the child to

        :raises:
            KeyError - when an index is invalid
            ValueError - when the value is not an instance of Asn1Value
        r	rzK
                No child is defined for position %d of %s
                zz
                Value for child %s of %s is not an instance of
                asn1crypto.core.Asn1Value
                N)	rAr�r�rr
r0r&r?r�)rIr�r6r)r)r*r�:s�
�	zConcat.__setitem__cCs
t|j�S)zB
        :return:
            An iterator of child values
        )r�r�rUr)r)r*r�^szConcat.__iter__)F)NNF)r	)F)r�r�r�r�r�r�r�r'rOrVrSrTr[rcrgrbrarwrZr�rGr�r�r�r�r)r)r)r*r�Fs,
-



$r�c@sDeZdZdZdZdZddd�Zdd�Zdd	d
�Zdd�Z	d
d�Z
dS)�	PrimitivezO
    Sets the class_ and method attributes for primitive, universal values
    rNc
Ks�tj|fi|��z:|dur$||_n&|dur8|�|�n|durJ|�|�WnXttfy�}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00dS)a^
        Sets the value of the object before passing to Asn1Value.__init__()

        :param value:
            A native Python datatype to initialize the object value with

        :param default:
            The default value if no value is specified

        :param contents:
            A byte string of the encoded contents of the value
        Nr	rr;)r&rOrGrEr?r1rHr
)rIr6rMrGr5rNrHr)r)r*rOpszPrimitive.__init__cCsHt|t�s"ttdt|�t|����||_||_d|_|jdkrDd|_dS)�_
        Sets the value of the object

        :param value:
            A byte string
        �H
                %s value must be a byte string, not %s
                Nr+)	r0rr1rr
rnrGrr�r�r)r)r*rE�s
�
z
Primitive.setFcCsD|jdur |jdd�dkr d}|r:|j}d|_|�|�t�|�S)r|Nr}r~T)rrxrGrEr&rZ�rIr�rxr)r)r*rZ�s

zPrimitive.dumpcCs
||kS)Nr)r�r)r)r*�__ne__�szPrimitive.__ne__cCs�t|t�sdS|j|jkrdS|jj|jjkr2dS|j|jkrN|j|jkrNdSt|jj�t|jg�Bttttg�}t|jj�t|jg�Bttttg�}||Br�|j|jkS|j	s�|j
s�|j	s�|j
r�|����|����kS|��|��kS)r�FT)
r0r�rGr<r2rE�	__bases__r&r�r:r9rlrZ)rIrpZ
self_bases�other_basesr)r)r*r��s	
&&zPrimitive.__eq__)NNN)F)r�r�r�r�rDrFrOrErZr�r�r)r)r)r*r�gs

r�csDeZdZdZdZdZdd�Zdd�Z�fdd	�Ze	d
d��Z
�ZS)�AbstractStringz�
    A base class for all strings that have a known encoding. In general, we do
    not worry ourselves with confirming that the decoded values match a specific
    set of characters, only that they are decoded into a Python unicode string
    �latin1NcCsbt|t�s"ttdt|�t|����||_|�|j�|_d|_	|j
rNd|_
d|_|jdkr^d|_dS)zb
        Sets the value of the string

        :param value:
            A unicode string
        �K
                %s value must be a unicode string, not %s
                NFrr+)
r0rr1rr
�_unicoder]�	_encodingrGrr�rFr�r�r)r)r*rE�s
�
zAbstractString.setcCs0|jdurdS|jdur*|���|j�|_|jS)rWN�)rGr�r��decoder�rUr)r)r*rT
s


zAbstractString.__unicode__cstt|��||�|j|_dS)a&
        Copies the contents of another AbstractString object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r�rar�ror�r)r*raszAbstractString._copycCs|jdurdS|��S�z�
        The native Python datatype representation of this value

        :return:
            A unicode string or None
        N)rGrTrUr)r)r*rx(s	
zAbstractString.native)r�r�r�r�r�r�rErTrar�rxr�r)r)r�r*r��sr�c@s8eZdZdZdZdd�Zdd�Zdd�Zed	d
��Z	dS)�Booleanz7
    Represents a boolean in both ASN.1 and Python
    r	cCs2t|�|_|sdnd|_d|_|jdkr.d|_dS)z�
        Sets the value of the object

        :param value:
            True, False or another value that works with bool()
        ���Nr+)�boolrnrGrr�r�r)r)r*rE>s


zBoolean.setcCs|��S)�4
        :return:
            True or False
        )�__bool__rUr)r)r*r�MszBoolean.__nonzero__cCs
|jdkS)r�r�r�rUr)r)r*r�TszBoolean.__bool__cCs(|jdurdS|jdur"|��|_|jS)z{
        The native Python datatype representation of this value

        :return:
            True, False or None
        N)rGrnr�rUr)r)r*rx[s
	


zBoolean.nativeN)
r�r�r�r�r2rEr�r�r�rxr)r)r)r*r�7sr�c@s0eZdZdZdZdd�Zdd�Zedd��Zd	S)
�Integerz8
    Represents an integer in both ASN.1 and Python
    r!cCs�t|t�rP|jdur&ttdt|����||jvrDttdt|�|���|j|}n"t|t�srttdt|�t|����|jr�||jvr�|j|n||_	t
|dd�|_d|_|j
dkr�d|_
dS)z�
        Sets the value of the object

        :param value:
            An integer, or a unicode string if _map is set

        :raises:
            ValueError - when an invalid value is passed
        Nz\
                    %s value is a unicode string, but no _map provided
                    zR
                    %s value, %s, is not present in the _map
                    z�
                %s value must be an integer or unicode string when a name_map
                is provided, not %s
                T��signedr+)r0rr�r?rr
r�rr1rnrrGrr�r�r)r)r*rEss0

�
�
�	 
zInteger.setcCst|jdd�S)�1
        :return:
            An integer
        Tr�)rrGrUr)r)r*�__int__�szInteger.__int__cCsL|jdurdS|jdurF|��|_|jdurF|j|jvrF|j|j|_|jS�zz
        The native Python datatype representation of this value

        :return:
            An integer or None
        N)rGrnr�r�rUr)r)r*rx�s	


zInteger.nativeN)	r�r�r�r�r2rEr�r�rxr)r)r)r*r�ls0r�cs@eZdZdZdZdd�Zdd�Z�fdd�Zed	d
��Z	�Z
S)�_IntegerBitStringzY
    A mixin for IntegerBitString and BitString to parse the contents as an integer.
    r)cCs�|jr
gStrt|jd�n|jd}t|jdd��}t|j�dd}|sZ||dfgSt|j�dkrvtd�|���|dkr�td�|���t|d|>d@|�}||L}||8}|||fgS)	a�
        Parse the contents of a primitive BitString encoding as an integer value.
        Allows reconstructing indefinite length values.

        :raises:
            ValueError - when an invalid value is passed

        :return:
            A list with one tuple (value, bits, unused_bits) where value is an integer
            with the value of the BitString, bits is the bit count of value and
            unused_bits is a tuple of 1s and 0s.
        rr	N�r)�$Empty bit string has {0} unused bits��Bit string has {0} unused bits)	r�rR�ordrGrrAr?�format�_int_to_bit_tuple)rI�unused_bits_lenr6�bits�unused_bitsr)r)r*r��sz_IntegerBitString._as_chunkcCs`|js|��dSd}d}d}|��D].\}}}|d@r@td��||7}||>|B}q&|||fS)aa
        Combines the chunks into a single value.

        :raises:
            ValueError - when an invalid value is passed

        :return:
            A tuple (value, bits, unused_bits) where value is an integer with the
            value of the BitString, bits is the bit count of value and unused_bits
            is a tuple of 1s and 0s.
        rr)r�4Only last chunk in a bit string may have unused bits)r�r�r�r?)rIr6Z
total_bitsr	�chunkrr)r)r*�_chunks_to_int�s
z _IntegerBitString._chunks_to_intcstt|��||�|j|_dS)a)
        Copies the contents of another _IntegerBitString object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r�ra�_unused_bitsror�r)r*rasz_IntegerBitString._copycCs|j|jS�zp
        The unused bits of the bit string encoding.

        :return:
            A tuple of 1s and 0s
        �rxr
rUr)r)r*r	s
z_IntegerBitString.unused_bits)r�r�r�r�r
r�rrar�r	r�r)r)r�r*r��s'r�c@sDeZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	e
dd
��ZdS)�	BitStringzK
    Represents a bit string from ASN.1 as a Python tuple of 1s and 0s
    rNcCs2t�|�|j}|jdur.t|j���d|_dS)r�Nr	)r�r8r<r��max�keys�_size)rIr4r)r)r*r82s

zBitString._setupc
Cst|t�r�|jdur&ttdt|����dg|j}||_td|j�D]*}|j�	|�}|dur^qD||vrDd||<qDd�
tt|��}n~|j
tkr�|jdur�||_n8t�|_t|�D]&\}}|r�|j�	||�}|j�|�q�d�
tt|��}nttdt|�t|����|jdu�rBt|�|jk�r8ttdt|�|jt|����|�d�}t|�}|d	}d}	|dk�rtd	|}	|d|	7}tt�|d	��}
|	�r�t|	�}nd
}|dk�r�d}ntt|d��}t|�|
k�r�d
|
t|�|}|||_d
|	|_d|_|j�rd|_d|_|jdk�rd|_dS)z�
        Sets the value of the object

        :param value:
            An integer or a tuple of integers 0 and 1

        :raises:
            ValueError - when an invalid value is passed
        N�F
                    %s._map has not been defined
                    rr	r�z�
                %s value must be a tuple of ones and zeros or a set of unicode
                strings, not %s
                zf
                    %s value must be at most %s bits long, specified was %s long
                    �0rr�r+r!�rF)r0rEr�r?rr
rrn�rangerjr��maprr<r�r��addr1rA�rstrip�int�math�ceilrrGr
rr�rFr�)
rIr6rr�r��bitr��sizeZsize_modZ
extra_bitsZ
size_in_bytesZextra_bits_byteZvalue_bytesr)r)r*rE=sz

�


�	�





z
BitString.setcCs�t|t�}|sJt|jt�s,ttdt|����||jvrJttdt|�|���|jdurZ|j	|jdur�t
|j�|dkr�t|j|�SdS|r�|j�||�}||jvS)aG
        Retrieves a boolean version of one of the bits based on a name from the
        _map

        :param key:
            The unicode string of one of the bit names

        :raises:
            ValueError - when _map is not set or the key name is invalid

        :return:
            A boolean if the bit is set
        r�T
                    %s._map does not contain an entry for "%s"
                    Nr	F)
r0rr�rir?rr
r�rnrxrAr�rj)rIr��is_intr)r)r*r��s,
�
�

zBitString.__getitem__cCst|t�}|sH|jdur*ttdt|����||jvrHttdt|�|���|jdurX|j|jdur�t	|j�}t
|�d}||kr�|�dg||�|r�dnd||<t|�|_nD|r�|j�
||�}|r�||jvr�|j�|�n||jvr�|j�|�|�|j�dS)a
        Sets one of the bits based on a name from the _map

        :param key:
            The unicode string of one of the bit names

        :param value:
            A boolean value

        :raises:
            ValueError - when _map is not set or the key name is invalid
        Nrr r	r)r0rr�r?rr
r�rnrxr�rA�extendr�rjr�removerE)rIr�r6r!Z
new_nativeZmax_keyr)r)r*r��s<

�
�




zBitString.__setitem__cCs�|jdur,|jdur |�d�n|�t��|jdur�|��\}}|_t||�}|jr�t�|_t|�D]&\}}|rf|j�||�}|j�	|�qfn||_|jS)z�
        The native Python datatype representation of this value

        :return:
            If a _map is set, a set of names, or if no _map is set, a tuple of
            integers 1 and 0. None if no value.
        Nr))
rGr�rErnrr
rr�rjr)rIZ	int_valueZ	bit_countrr�rr�r)r)r*rx	s



zBitString.native)r�r�r�r�r2rr8rEr�r�r�rxr)r)r)r*r)sc/9rcs\eZdZdZdZdZdZdd�Zdd�Z�fd	d
�Z	dd�Z
ed
d��Zedd��Z
�ZS)�OctetBitStringzB
    Represents a bit string in ASN.1 as a Python byte string
    rNr)cCsdt|t�s"ttdt|�t|����||_d||_d|_d|_|j	rPd|_	d|_
|jdkr`d|_dS)��
        Sets the value of the object

        :param value:
            A byte string

        :raises:
            ValueError - when an invalid value is passed
        r�r�r)NFrr+)r0rr1rr
�_bytesrGr
rr�rFr�r�r)r)r*rE5	s
�

zOctetBitString.setcCs�|jdurdS|jdurz|js4|��d\|_|_nF|��}d|_|D]}|jrXtd��|d|_qFd�dd�|D��|_|jS)	�4
        :return:
            A byte string
        Nr+rr)r
r	css|]}|dVqdS)rNr))r�rr)r)r*�	<genexpr>g	r+z+OctetBitString.__bytes__.<locals>.<genexpr>)rGr&r�r�r
r�r?r�)rI�chunksrr)r)r*rST	s

zOctetBitString.__bytes__cs&tt|��||�|j|_|j|_dS)a&
        Copies the contents of another OctetBitString object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r$rar&r
ror�r)r*rak	szOctetBitString._copycCs�trt|jd�n|jd}|s4|jdd�dfgSt|j�dkrPtd�|���|dkrftd�|���d|>d}tr�t|jd�n|jd}||@}|jdd�tr�t|�nt|f�}t||@|�}||fgS)	z�
        Allows reconstructing indefinite length values

        :raises:
            ValueError - when an invalid value is passed

        :return:
            List with one tuple, consisting of a byte string and an integer (unused bits)
        rr	Nr)rrrr})	rRrrGrAr?r�chr�bytesr)rIr�maskZ	last_byteZzeroed_byter6r	r)r)r*r�{	s
$zOctetBitString._as_chunkcCs|jdurdS|��S��}
        The native Python datatype representation of this value

        :return:
            A byte string or None
        N�rGrSrUr)r)r*rx�	s	
zOctetBitString.nativecCs|j|jSrrrUr)r)r*r	�	s
zOctetBitString.unused_bits)r�r�r�r�r2r&r
rErSrar�r�rxr	r�r)r)r�r*r$(	s"

r$c@s(eZdZdZdZdd�Zedd��ZdS)�IntegerBitStringz>
    Represents a bit string in ASN.1 as a Python integer
    rcCs�t|t�s"ttdt|�t|����|dkr>ttdt|�|���||_dt|dd�|_d|_	d|_
|jrtd	|_d|_|j
d
kr�d
|_
dS)��
        Sets the value of the object

        :param value:
            An integer

        :raises:
            ValueError - when an invalid value is passed
        �M
                %s value must be a positive integer, not %s
                r�M
                %s value must be a positive integer, not %d
                r�Tr�r)NFr+)r0rr1rr
r?rnrrGr
rr�rFr�r�r)r)r*rE�	s*
��
zIntegerBitString.setcCs0|jdurdS|jdur*|��\|_}|_|jSr�)rGrnrr
)rI�__r)r)r*rx�	s
	

zIntegerBitString.nativeN�r�r�r�r�r2rEr�rxr)r)r)r*r0�	s
(r0csDeZdZdZdZdZdd�Zdd�Z�fdd	�Ze	d
d��Z
�ZS)�OctetStringz;
    Represents a byte string in both ASN.1 and Python
    �NcCsZt|t�s"ttdt|�t|����||_||_d|_|jrFd|_d|_	|j
dkrVd|_
dS�r�r�NFrr+�r0rr1rr
r&rGrr�rFr�r�r)r)r*rE
s
�
zOctetString.setcCs(|jdurdS|jdur"|��|_|jS�r'Nr+�rGr&r�rUr)r)r*rS
s



zOctetString.__bytes__cstt|��||�|j|_dS)a#
        Copies the contents of another OctetString object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r6rar&ror�r)r*ra+
szOctetString._copycCs|jdurdS|��Sr-r/rUr)r)r*rx:
s	
zOctetString.native)r�r�r�r�r2r&rErSrar�rxr�r)r)r�r*r6�	sr6c@s4eZdZdZdZdZdd�Zedd��Zdd	�Z	dS)
�IntegerOctetStringz?
    Represents a byte string in ASN.1 as a Python integer
    r7NcCs�t|t�s"ttdt|�t|����|dkr>ttdt|�|���||_t|d|jd�|_	d|_
|jrnd|_d|_|j
dkr~d|_
dS)r1r2rr3F)r��widthNr+)r0rr1rr
r?rnr�_encoded_widthrGrr�rFr�r�r)r)r*rEV
s(
��
zIntegerOctetString.setcCs,|jdurdS|jdur&t|���|_|jSr�)rGrnrr�rUr)r)r*rx|
s
	

zIntegerOctetString.nativecCs.||_|jdur*t|j�|kr*|�|j�dS)z�
        Set the explicit enoding width for the integer

        :param width:
            An integer byte width to encode the integer to
        N)r>rGrArErx)rIr=r)r)r*�set_encoded_width�
sz$IntegerOctetString.set_encoded_width)
r�r�r�r�r2r>rEr�rxr?r)r)r)r*r<I
s&
r<csveZdZdZdZdZddd�Zdd�Zddd�Zd	d
�Z	dd�Z
�fd
d�Zedd��Z
edd��Zddd�Z�ZS)�ParsableOctetStringr7NcKsVd}|dur*|dur*t|t�r*|��}d}tj|fd|i|��|rR||jdf|_dS)a�
        Allows providing a parsed object that will be serialized to get the
        byte string value

        :param value:
            A native Python datatype to initialize the object value with

        :param parsed:
            If value is None and this is an Asn1Value object, this will be
            set as the parsed value, and the value will be obtained by calling
            .dump() on this object.
        FNTr6)r0r&rZr�rOr<r�)rIr6rtr5Z
set_parsedr)r)r*rO�
szParsableOctetString.__init__cCsZt|t�s"ttdt|�t|����||_||_d|_|jrFd|_d|_	|j
dkrVd|_
dSr8r9r�r)r)r*rE�
s
�
zParsableOctetString.setcCsL|jdus |jdd�||fkrBt|��||d�\}}|||f|_|jdS)r�Nr	rr�r)r�r3rS)rIr.r/r�r7r)r)r*r��
s zParsableOctetString.parsecCs(|jdurdS|jdur"|��|_|jSr:r;rUr)r)r*rS�
s



zParsableOctetString.__bytes__cCs|��S)z�
        Returns a byte string that can be passed into .set()

        :return:
            A python value that is valid to pass to .set()
        )rSrUr)r)r*r��
sz#ParsableOctetString._setable_nativecs*tt|��||�|j|_||j�|_dS)a+
        Copies the contents of another ParsableOctetString object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�r@rar&r�ror�r)r*raszParsableOctetString._copycCs0|jdurdS|jdur$|jdjS|��SdS)r.Nr)rGr�rxrSrUr)r)r*rxs
	

zParsableOctetString.nativecCs|jdur|��|jdSr�r�rUr)r)r*rt#s	
zParsableOctetString.parsedFcCsH|jr
d}|r>|jdur(|jj|d�}n|j}d|_|�|�t�|�S)r|TNr�)r�r�rtrZrxrGrEr&r�r)r)r*rZ1s


zParsableOctetString.dump)NN)NN)F)r�r�r�r2r�r&rOrEr�rSr�rar�rxrtrZr�r)r)r�r*r@�
s





r@c@s eZdZdZdd�Zdd�ZdS)�ParsableOctetBitStringrcCs^t|t�s"ttdt|�t|����||_d||_d|_|jrJd|_d|_	|j
dkrZd|_
dS)r%r�r�NFrr+r9r�r)r)r*rEPs
�

zParsableOctetBitString.setcCs6trt|jd�n|jd}|r(td��|jdd�S)z�
        Allows reconstructing indefinite length values

        :raises:
            ValueError - when an invalid value is passed

        :return:
            A byte string
        rz1ParsableOctetBitString should have no unused bitsr	N)rRrrGr?)rIrr)r)r*r�nsz ParsableOctetBitString._as_chunkN)r�r�r�r2rEr�r)r)r)r*rALsrAc@s,eZdZdZdZdZdd�Zedd��ZdS)	�Nullz<
    Represents a null value in ASN.1 as None in Python
    �r+cCs
d|_dS)zV
        Sets the value of the object

        :param value:
            None
        r+Nr�r�r)r)r*rE�szNull.setcCsdSr�r)rUr)r)r*rx�s	zNull.nativeN)	r�r�r�r�r2rGrEr�rxr)r)r)r*rB�s
rBc@sXeZdZdZdZdZedd��Zedd��Zdd	�Z	d
d�Z
edd
��Zedd��Z
dS)�ObjectIdentifier�`
    Represents an object identifier in ASN.1 as a Python unicode dotted
    integer string
    �NcCsF|jdurttdt|����t|t�s8ttdt|����|j�||�S)a^
        Converts a dotted unicode string OID into a mapped unicode string

        :param value:
            A dotted unicode string OID

        :raises:
            ValueError - when no _map dict has been defined on the class
            TypeError - when value is not a unicode string

        :return:
            A mapped unicode string
        N�>
                %s._map has not been defined
                �H
                value must be a unicode string, not %s
                )r�r?rr
r0rr1rj�r4r6r)r)r*r�s
�
�zObjectIdentifier.mapcCs�|tvr|���dt|<|jdur6ttdt|����t|t�sRttdt|����||j	vrf|j	|St
�|�s�ttdt|�|���|S)a�
        Converts a mapped unicode string value into a dotted unicode string OID

        :param value:
            A mapped unicode string OR dotted unicode string OID

        :raises:
            ValueError - when no _map dict has been defined on the class or the value can't be unmapped
            TypeError - when value is not a unicode string

        :return:
            A dotted unicode string OID
        TNrGrHzL
                %s._map does not contain an entry for "%s"
                )r=r8r�r?rr
r0rr1r��_OID_RE�matchrIr)r)r*�unmap�s,

�
�


�zObjectIdentifier.unmapcCs8t|t�s"ttdt|�t|����||_|jdurF||jvrF|j|}d|_d}t	|�
d��D]�\}}t|�}|dkr~|}q^nR|dkr�|dkr�ttdt
|����n"|dkr�|d	kr�ttd
t
|����|d	|}td|@�}|d?}|dk�rtd
d|@B�|}|d?}q�|j|7_q^d|_|jdk�r4d|_dS)a
        Sets the value of the object

        :param value:
            A unicode string. May be a dotted integer string, or if _map is
            provided, one of the mapped values.

        :raises:
            ValueError - when an invalid value is passed
        r�Nr+�.rr	r!z\
                        First arc must be one of 0, 1 or 2, not %s
                        �(z�
                        Second arc must be less than 40 if first arc is 0 or
                        1, not %s
                        �r�)r0rr1rr
rnr�r�rGr��splitrr?r@rrr�)rIr6�firstr��partZencoded_partr)r)r*rE�sL
�


��

zObjectIdentifier.setcCs|jSr�)�dottedrUr)r)r*rT?szObjectIdentifier.__unicode__cCs�|jdur�g}d}|jD]�}tr(t|�}|d}||d@7}|d@dkrt|�dkr�|dkr~|�td��|�t|d��q�|dkr�|�td��|�t|d��q�|�td��|�t|��n|�t|��d}qd	�|�|_|jS)
z�
        :return:
            A unicode string of the object identifier in dotted notation, thus
            ignoring any mapped value
        NrrPrO�Pr!rNr	rM)�_dottedrGrRrrAr�rr�)rIr�rS�byter)r)r*rTGs,

zObjectIdentifier.dottedcCsJ|jdurdS|jdur |j|_|jdurD|j|jvrD|j|j|_|jS)aC
        The native Python datatype representation of this value

        :return:
            A unicode string or None. If _map is not defined, the unicode string
            is a string of dotted integers. If _map is defined and the dotted
            string is present in the _map, the mapped value is returned.
        N)rGrnrTr�rUr)r)r*rxks

zObjectIdentifier.native)r�r�r�r�r2rVr�rrLrErTr�rTrxr)r)r)r*rD�s
!
1A
#rDc@seZdZdZdZdS)�ObjectDescriptorzO
    Represents an object descriptor from ASN.1 - no Python implementation
    rN�r�r�r�r�r2r)r)r)r*rX�srXc@seZdZdZdZdS)�
InstanceOfzF
    Represents an instance from ASN.1 - no Python implementation
    rNrYr)r)r)r*rZ�srZc@seZdZdZdZdS)�RealzH
    Represents a real number from ASN.1 - no Python implementation
    �	NrYr)r)r)r*r[�sr[c@s(eZdZdZdZdd�Zedd��ZdS)�
Enumeratedz\
    Represents a enumerated list of integers from ASN.1 as a Python
    unicode string
    �
cCs�t|t�s,t|t�s,ttdt|�t|����t|t�r`||jvrTttdt|�|���|j|}n||jvr~ttdt|�|���t	�
||�dS)z�
        Sets the value of the object

        :param value:
            An integer or a unicode string from _map

        :raises:
            ValueError - when an invalid value is passed
        zY
                %s value must be an integer or a unicode string, not %s
                zL
                    %s value "%s" is not a valid value
                    zB
                %s value %s is not a valid value
                N)r0rrr1rr
r�r?r�r�rEr�r)r)r*rE�s*�

�
�zEnumerated.setcCs.|jdurdS|jdur(|j|��|_|jSr�)rGrnr�r�rUr)r)r*rx�s
	

zEnumerated.nativeNr5r)r)r)r*r]�s
+r]c@seZdZdZdZdZdS)�
UTF8StringzI
    Represents a UTF-8 string from ASN.1 as a Python unicode string
    �r\N�r�r�r�r�r2r�r)r)r)r*r_�sr_c@seZdZdZdZdS)�RelativeOidrE�
NrYr)r)r)r*rb�srbcseZdZdZdZdZdZdZdZdZ	gZ
dZdZdZ
dZdZdZdZd.dd�Zed	d
��Zejdd
��Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd/dd�Zdd�Zdd�Zd d!�Z d0d"d#�Z!d$d%�Z"ed&d'��Z#�fd(d)�Z$d1d*d+�Z%d2d,d-�Z&�Z'S)3�Sequencezf
    Represents a sequence of fields from ASN.1 as a Python object with a
    dict-like interface
    �rr	NFc
Ks�tj|fi|��d}|durP|durPd}|jdurL|jdurDd}n|��|}|du�r�z�|jr�dd�|jD�}t|���}n|��}t|�}|D]d}|r�|j|}|t	|j�kr�|j|t
ur�||vr�|�|�q�||vr�|�|||�|�|�q�t	|��r&t
tdt|�d�tt|������WnZt
tf�y�}	z<|	jdd�}
|	jd	d
t|�f|
|	_|	�WYd}	~	n
d}	~	00dS)a"
        Allows setting field values before passing everything else along to
        Asn1Value.__init__()

        :param value:
            A native Python datatype to initialize the object value with

        :param default:
            The default value if no value is specified
        FNTcSsg|]}|d�qSrr))r�r�r)r)r*r�E
r+z%Sequence.__init__.<locals>.<listcomp>z�
                        One or more unknown fields was passed to the constructor
                        of %s: %s
                        r�r	rr;)r&rO�childrenrG�_parse_children�_fieldsrEr�
_field_maprA�VOIDr#r�r?rr
r��sortedr�r1rH)rIr6rMr5Zcheck_existingrZunused_keysr�r�rNrHr)r)r*rO'
sH





�
	zSequence.__init__cCs&|jdur|jS|��r |��|jS�z`
        :return:
            A byte string of the DER-encoded contents of the sequence
        N�rfr��_is_mutated�
_set_contentsrUr)r)r*rGh
s

zSequence.contentscCs
||_dS�ze
        :param value:
            A byte string of the DER-encoded contents of the sequence
        Nr�r�r)r)r*rGw
scCs@|j}|jdur<|jD]$}t|t�s.t|t�r|p8|��}q|S�z~
        :return:
            A boolean - if the sequence or any children (recursively) have been
            mutated
        N��_mutatedrfr0rd�
SequenceOfrn�rIZmutatedr�r)r)r*rn�
s

zSequence._is_mutatedcCs*|j|}|jtkr&t|�}|j|<|S�z]
        Builds a child object if the child has only been parsed into a tuple so far
        �rfr<r��_build�rIr�r�r)r)r*�_lazy_child�
s

zSequence._lazy_childcCs|jdur|��t|j�S)r�N�rfrgrArUr)r)r*r��
s
zSequence.__len__c
Cs�|jdur|��t|t�sD||jvr:ttd|t|����|j|}|t|j�krfttd|t|����z|�	|�WSt
tfy�}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00dS)a9
        Allows accessing fields by name or index

        :param key:
            A unicode string of the field name, or an integer of the field index

        :raises:
            KeyError - when a field name or index is invalid

        :return:
            The Asn1Value object of the field specified
        N�L
                    No field named "%s" defined for %s
                    zL
                No field numbered %s is present in this %s
                r	rr�)
rfrgr0rrir�rr
rArzr?r1rH)rIr�rNrHr)r)r*r��
s,


�
�zSequence.__getitem__c
Cs�|jdur|��t|t�sD||jvr:ttd|t|����|j|}|�|�\}}}}}|�	|||||�}d}	t|t
�r�|jdu}	n
|jdu}	|	r�t
td|t|����||j|<|jdur�|j|j|j|j|d<d|_dS)a�
        Allows settings fields by name or index

        :param key:
            A unicode string of the field name, or an integer of the field index

        :param value:
            A native Python datatype to set the field value to. This method will
            construct the appropriate Asn1Value object from _fields.

        :raises:
            ValueError - when a field name or index is invalid
        Nr|FzG
                Value for field "%s" of %s is not set
                rT)rfrgr0rrir�rr
�_determine_spec�_make_valuer�rtrGr?rnrxrhrs)
rIr�r6�
field_name�
field_spec�
value_spec�field_paramsr7�	new_valueZ
invalid_valuer)r)r*r��
s4


�


�

zSequence.__setitem__cCs�|jdur|��t|t�sD||jvr:ttd|t|����|j|}|j|\}}}|rhd|vr|d|vr|t	td|t|����d|vr�t
|j|<|jdur�d|j|<n|�|d�d|_
dS)a/
        Allows deleting optional or default fields by name or index

        :param key:
            A unicode string of the field name, or an integer of the field index

        :raises:
            ValueError - when a field name or index is invalid, or the field is not optional or defaulted
        Nr|rMrLz�
                Can not delete the value for the field "%s" of %s since it is
                not optional or defaulted
                T)rfrgr0rrir�rr
rhr?rjrnr�rs)rIr�r�r7r�r)r)r*�__delitem__	s.


�
�	

zSequence.__delitem__ccs|jD]}|dVqdS)zE
        :return:
            An iterator of field key names
        rN)rh)rIr�r)r)r*r�6s
zSequence.__iter__cCs�|jdur|��t�}t|j�D]�\}}|j|}|durBd}nH|jtkr~|rd|�|�j|d�}q�|d|d|d}n|j|d�}|dr�d|dvr�|d	fi|d��}|��|kr�q"|�	|�q"|�
�|_d|_|j
dkr�d|_
dS)
a
        Updates the .contents attribute of the value with the encoded value of
        all of the child objects

        :param force:
            Ensure all contents are in DER format instead of possibly using
            cached BER-encoded data
        Nr+r�rr7rCr!rMr	)rfrgrr�rhr<r�rzrZ�write�getvaluer�rr�)rIr�rGr�r�r�Z
child_dump�
default_valuer)r)r*ro?s*





zSequence._set_contentscCs$|j}i|_g|_g|_t|j�D]P\}}t|�dkrJ|if}||j|<||j|d<|j�t|d|d��q"|j	dur�|j|j	d|j|j	df|_
t|j�D]t\}}|jduo�|d|jv}|j
duo�|j
d|k}|s�|r�|j�d�q�|j�|d|d|d|ddf�q�dS�zS
        Generates _field_map, _field_ids and _oid_nums for use in parsing
        rrr!r	N)r<ri�
_field_ids�_precomputed_specsr�rhrAr�r��	_oid_pair�	_oid_nums�_spec_callbacks�rIr4r��fieldZhas_callbackZ
is_mapped_oidr)r)r*r8ds$


"zSequence._setupc	Cs�|j|\}}}|}d}|jdur�||jvr�|j|}||�}|r�|jtkrrt|�dkrr|\}}|dur�|}d}q�|dur�|}|}d}q�|}nB|jdur�|jd|kr�|�|jd�j}||jvr�|j|}|}|||||fS)a
        Determine how a value for a field should be constructed

        :param index:
            The field number

        :return:
            A tuple containing the following elements:
             - unicode string of the field name
             - Asn1Value class of the field spec
             - Asn1Value class of the value spec
             - None or dict of params to pass to the field spec
             - None or Asn1Value class indicating the value spec was derived from an OID or a spec callback
        Nr!r	r)	rhr�r<r�rAr�rzrx�
_oid_specs)	rIr�r�r�r�r��
spec_override�callback�oidr)r)r*r}s.


zSequence._determine_specc
Cs�|durd|vrtS||k}t|t�}t|t�r�t|t�}t|t�oNt|�dk}	t|t�odt|�dk}
|s�|	s�|
s�t	t
d|t|����|	s�|
r�||�}t||�s�|�}|�|j
|j|j�||_|}n|}n�t||�r�|}|r�|�|�n�|r�|�rDt||��sD|�r|�r2t|t��r2tt
d|t|�t|����||fi|��}ntt||��rV|}n.t|t��r|tt
d|t|�t|����||�}|�r�|�s�|fd|��i|��}||jdf|_|}t||�}|S)	a&
        Contructs an appropriate Asn1Value object for a field

        :param field_name:
            A unicode string of the field name

        :param field_spec:
            An Asn1Value class that is the field spec

        :param value_spec:
            An Asn1Value class that is the vaue spec

        :param field_params:
            None or a dict of params for the field spec

        :param value:
            The value to construct an Asn1Value object from

        :return:
            An instance of a child class of Asn1Value
        NrLr!r	z�
                    Can not set a native python value to %s, which has the
                    choice type of %s - value must be an instance of Asn1Value
                    zE
                    %s value must be %s, not %s
                    zM
                        %s value must be %s, not %s
                        r6)rj�
issubclassr�r�r0r&r�rArir?rr
r�rDr2rGr�r�r1rZr<r�)
rIrr�r�r�r6Zspecs_differentZis_anyZis_asn1valueZis_tupleZis_dict�wrapperr�r)r)r*r~�sf


�

��
zSequence._make_valuec
Cs>|j}|jdur�|jr�tgt|j�|_t|j�D]b\}\}}}d|vr2|j|rh|j|\}}}}	}n|�|�\}}}}	}|�	||||	d�|j|<q2dS�z<g|_t|j�}
d}d}t|j�}
d}||
k}|�r^|dur�t
|j|
|d�\}}||
k}||
k�r@|j|�p|�|�\}}}}	}|	�r�d|	v�s:d|	v�r�|j||d|dfk�r�|tk�r�d}t
|t��r�z0|fi|	��}|�|d|d|d�d	}Wnt�y�Yn0|�s�d|	v�r�|j�t�n|j�|fi|	���|d
7}d	}q�|du�s|�rt
|t��r|}d}|�r2|||	|f}n|||	f}n�|
dk�r|d
|
k�rg}|d
}|dk�r�|j|}t|�dk�r��q�d|dv�s�d|dv�r�|�|d�|d
8}�qdt|�d
k�r�dnd
}d�|�}ttd|d
t�|d�t�|d
�|d||���n|}|�rDt|�}t|ttf��rD|jd	d�|j�|�|d
7}d}q�t|j�}||
k�r�|j|\}}}	d|	v�r�|j�|fi|	���n&d|	v�r�|j�t�nttd|���|d
7}�qhWn`ttf�y8}zBd|_|jd
d�}|jddt|�f||_|�WYd}~n
d}~00dS)�Q
        Parses the contents and generates Asn1Value objects based on the
        definitions from _fields.

        :param recurse:
            If child objects that are Sequence or SequenceOf objects should
            be recursively parsed

        :raises:
            ValueError - when an error occurs parsing child objects
        NrMr�r�rLr!Fr7Tr	r�sr�r�z�
                        Data for field %s (%s class, %s method, tag %s) does
                        not match the field definition%s of %s
                        ��recursezV
                        Field "%s" is missing from structure
                        r�)r<r�rhrjrArfr�r�r}r~rr�r�r�r�r�r?r�r�rrBrj�METHOD_NUM_TO_NAME_MAPrxr0rdrtrgr1rHr
)rIr�r4r�r7r�rr�r�r��contents_length�
child_pointerr�Z	field_len�partsZagainr�Zchoice_match�testerr�Z
missed_fieldsZ
prev_fieldZprev_field_info�pluralZmissed_field_namesr�rNrHr)r)r*rgs�





�&



�



�zSequence._parse_childrencCsZt|t�sttdt|����|jdur>ttdt|�t|����|j|}|�	|�}|dS)a
        Determines the spec to use for the field specified. Depending on how
        the spec is determined (_oid_pair or _spec_callbacks), it may be
        necessary to set preceding field values before calling this. Usually
        specs, if dynamic, are controlled by a preceding ObjectIdentifier
        field.

        :param field_name:
            A unicode string of the field name to get the spec for

        :return:
            A child class of asn1crypto.core.Asn1Value that the field must be
            encoded using
        zM
                field_name must be a unicode string, not %s
                Nz�
                Unable to retrieve spec for field %s in the class %s because
                _fields has not been set
                r!)
r0rr1rr
rhr?r@rir})rIrr�r�r)r)r*r.�s
�
�	

z
Sequence.specc
Cs|jdurdS|jdu�r|jdur0|jdd�zvt�|_t|j�D]^\}}|jtkrht|�}||j|<z|j	|d}Wnt
y�t|�}Yn0|j|j|<qDWn`t
tf�y}zBd|_|jdd�}|jddt|�f||_|�WYd}~n
d}~00|jS)z�
        The native Python datatype representation of this value

        :return:
            An OrderedDict or None. If an OrderedDict, all child values are
            recursively converted to native representation also.
        NTr�rr	r�)rGrnrfrgrr�r<r�rxrh�
IndexErrorrrxr?r1rHr
)rIr�r�r�rNrHr)r)r*rx�s,




zSequence.nativecsZtt|��||�|jdurVg|_|jD],}|jtkrD|j�|�q(|j�|���q(dS)a 
        Copies the contents of another Sequence object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�rdrarfr<r�r�rb�rIrprqr�r�r)r*ra�s


zSequence._copycCsh|jdur|��d|}t||�|D]:}|�|j|�}|tur(td||f�|�|d�q(dS)rrNrsz%s    Field "%s"r)rfrgrvrzrirjryrw)rIrzr{rr�r)r)r*rw�s

zSequence.debugcCs�|jdur |jdd�dkr d}|r<|jgkr<|jtur<d}|rL|j|d�|jr�|jdur�t|j�D]>\}\}}}|j|tur�qfd|vsfd|vr�qftt	d	|���qft
�|�S)
r|Nr}r~TFr�rMrLzN
                    Field "%s" is missing from structure
                    )rrhr<rdrorfr�rjr?rr&rZ)rIr�r�rr7r�r)r)r*rZs"
�z
Sequence.dump)NN)F)F)r	)F)(r�r�r�r�r2rDrFrfr�rsrhr�rir�r�r�r�r�rOr�rGr�rnrzr�r�r�r�r�ror8r}r~rgr.rxrarwrZr�r)r)r�r*rd�sN
A


.7-	
%/`
	'
!
rdcs�eZdZdZdZdZdZdZdZdZ	dZ
d.dd�Zed	d
��Z
e
jdd
��Z
dd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd/d d!�Zd0d"d#�Zd$d%�Zed&d'��Z�fd(d)�Zd1d*d+�Zd2d,d-�Z�Z S)3rtz�
    Represents a sequence (ordered) of a single type of values from ASN.1 as a
    Python object with a list-like interface
    rerr	NFc

Ks�|r
||_tj|fi|��z`|dur.||_nL|durB|durB|}|durzt|�D]\}}|�||�qR|jdurz|��WnXttfy�}z<|j	dd�}	|j	ddt
|�f|	|_	|�WYd}~n
d}~00dS)a
        Allows setting child objects and the _child_spec via the spec parameter
        before passing everything else along to Asn1Value.__init__()

        :param value:
            A native Python datatype to initialize the object value with

        :param default:
            The default value if no value is specified

        :param contents:
            A byte string of the encoded contents of the value

        :param spec:
            A class derived from Asn1Value to use to parse children
        Nr	rr;)�_child_specr&rOrGr�r�ror?r1rHr
)
rIr6rMrGr.r5r�r�rNrHr)r)r*rOCs"
zSequenceOf.__init__cCs&|jdur|jS|��r |��|jSrlrmrUr)r)r*rGns

zSequenceOf.contentscCs
||_dSrpr�r�r)r)r*rG}scCs@|j}|jdur<|jD]$}t|t�s.t|t�r|p8|��}q|Srqrrrur)r)r*rn�s

zSequenceOf._is_mutatedcCs*|j|}|jtkr&t|�}||j|<|Srvrwryr)r)r*rz�s



zSequenceOf._lazy_childcCs�t||j�r|}n�t|jt�rBt|t�r.|}q�ttdt|����nrt|jt�r�t|t�spttdt|�|jj	���t||j�s�|��}|�
|j|j|j
�||_|}|}n|j|d�Si}|jjr�|jj|d<|jjr�|jj|jjf|d<t||�S)a
        Constructs a _child_spec value from a native Python data type, or
        an appropriate Asn1Value object

        :param value:
            A native Python value, or some child of Asn1Value

        :return:
            An object of type _child_spec
        z�
                    Can not set a native python value to %s where the
                    _child_spec is Any - value must be an instance of Asn1Value
                    z�
                    Can not set a native python value to %s where the
                    _child_spec is the choice type %s - value must be an
                    instance of Asn1Value
                    )r6r9r:)r0r�r�r�r&r?rr
r�r�r�rDr2rGr�r9r:r�)rIr6r�r�r�r)r)r*r~�s:
�
�	zSequenceOf._make_valuecCs|jdur|��t|j�S)r�Nr{rUr)r)r*r��s
zSequenceOf.__len__cCs|jdur|��|�|�S)zm
        Allows accessing children via index

        :param key:
            Integer index of child
        N)rfrgrzr�r)r)r*r��s	
zSequenceOf.__getitem__cCs||jdur|��|�|�}|t|j�krL|j�d�|jdurL|j�d�||j|<|jdurr|j|j|j|<d|_dS)z�
        Allows overriding a child via index

        :param key:
            Integer index of child

        :param value:
            Native python datatype that will be passed to _child_spec to create
            new child object
        NT)rfrgr~rAr�rnrxrs)rIr�r6r�r)r)r*r��s




zSequenceOf.__setitem__cCs>|jdur|��|j�|�|jdur4|j�|�d|_dS)zk
        Allows removing a child via index

        :param key:
            Integer index of child
        NT)rfrg�poprnrsr�r)r)r*r�s	

zSequenceOf.__delitem__ccs8|jdur|��tdt|j��D]}|�|�Vq"dS)zA
        :return:
            An iter() of child objects
        Nr)rfrgrrArz)rIr�r)r)r*r�!s
zSequenceOf.__iter__cCs\|dus|turdSt||j�s@ttdt|�t|j�t|����|D]}||krDdSqDdS)z�
        :param item:
            An object of the type cls._child_spec

        :return:
            A boolean if the item is contained in this SequenceOf
        NFzy
                Checking membership in %s is only available for instances of
                %s, not %s
                T)rjr0r�r1rr
)rI�itemr�r)r)r*�__contains__.s	�
zSequenceOf.__contains__cCsL|jdur|��|j�|�|��|jdurB|j�|jdj�d|_dS)z�
        Allows adding a child to the end of the sequence

        :param value:
            Native python datatype that will be passed to _child_spec to create
            new child object
        Nr}T)rfrgr�r~rnrxrsr�r)r)r*r�Ks


zSequenceOf.appendcCsX|jdur|��t�}|D]}|�|j|d��q|��|_d|_|jdkrTd|_dS)z�
        Encodes all child objects into the contents for this object

        :param force:
            Ensure all contents are in DER format instead of possibly using
            cached BER-encoded data
        Nr�r+)	rfrgrr�rZr�r�rr�r�r)r)r*ro_s	


zSequenceOf._set_contentsc
Cs�z�g|_|jdurWdSt|j�}d}||kr�t|j||d�\}}|jrV||jf}n|}|r�t|�}t|ttf�r�|j	dd�|j�
|�q&Wn^ttfy�}zBd|_|j
dd�}|j
ddt|�f||_
|�WYd}~n
d}~00dS)aU
        Parses the contents and generates Asn1Value objects based on the
        definitions from _child_spec.

        :param recurse:
            If child objects that are Sequence or SequenceOf objects should
            be recursively parsed

        :raises:
            ValueError - when an error occurs parsing child objects
        Nrr�Tr�r	r�)rfr�rArr�rxr0rdrtrgr�r?r1rHr
)rIr�r�r�r�r�rNrHr)r)r*rgss*


zSequenceOf._parse_childrencCs|jS)z�
        Determines the spec to use for child values.

        :return:
            A child class of asn1crypto.core.Asn1Value that child values must be
            encoded using
        )r�rUr)r)r*r.�s	zSequenceOf.specc
Cs�|jdurdS|jdur�|jdur.|jdd�zdd�|D�|_WnXttfy�}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00|jS)	z�
        The native Python datatype representation of this value

        :return:
            A list or None. If a list, all child values are recursively
            converted to native representation also.
        NTr�cSsg|]
}|j�qSr)r�)r�r�r)r)r*r��r+z%SequenceOf.native.<locals>.<listcomp>r	rr�)rGrnrfrgr?r1rHr
)rIrNrHr)r)r*rx�s



zSequenceOf.nativecsZtt|��||�|jdurVg|_|jD],}|jtkrD|j�|�q(|j�|���q(dS)a"
        Copies the contents of another SequenceOf object to itself

        :param object:
            Another instance of the same class

        :param copy_func:
            An reference of copy.copy() or copy.deepcopy() to use when copying
            lists, dicts and objects
        N)r�rtrarfr<r�r�rbr�r�r)r*ra�s


zSequenceOf._copycCs@|jdur|��d|}t||�|D]}|�|d�q(dS)rrNrsr	)rfrgrvrwr�r)r)r*rw�s

zSequenceOf.debugcCs:|jdur |jdd�dkr d}|r0|j|d�t�|�S)r|Nr}r~Tr�)rror&rZr�r)r)r*rZ�s

zSequenceOf.dump)NNNN)F)F)r	)F)!r�r�r�r�r2rDrFrfr�rsr�rOr�rGr�rnrzr~r�r�r�r�r�r�r�rorgr.rxrarwrZr�r)r)r�r*rt+s>
+

7


$


rtc@s<eZdZdZdZdZdZdZdd�Zd
d	d
�Z	ddd�Z
dS)�Setzm
    Represents a set of fields (unordered) from ASN.1 as a Python object with a
    dict-like interface
    r	r�NcCs"|j}i|_i|_g|_t|j�D]N\}}t|�dkrJ|if}||j|<||j|d<||jt|d|d�<q"|jdur�|j|jd|j|jdf|_	t|j�D]t\}}|j
duo�|d|j
v}|j	duo�|j	d|k}|s�|r�|j�d�q�|j�|d|d|d|ddf�q�dSr�)r<rir�r�r�rhrAr�r�r�r�r�r�r)r)r*r8s$


"z
Set._setupFc
Cs2|j}|jdur�|jr�tgt|j�|_t|j�D]b\}\}}}d|vr2|j|rh|j|\}}}}	}n|�|�\}}}}	}|�	||||	d�|j|<q2dS�z6i}
t|j
�}d}d}
||k�r�t|j
||d�\}}|d|df}|j�
|�}|du�r$ttd|
t�
|d�t�
|d�|d���|j|�p8|�|�\}}}}	}|du�s`|�rht|t��rh|}d}|�r~|||	|f}n|||	f}|�r�t|�}t|ttf��r�|jdd	�||
|<|
d7}
q�t|j�}td|�D]�}||
v�r�q�|j|�p|�|�\}}}}	}|du�s(|�r0t|t��r0|}d}d
}|	�s@d}nJd|	v�rZd|	v�rZd}n0d|	v�rnt|
|<nd|	v�r�|fi|	��|
|<|�r�ttd|t|�����q�g|_td|�D]}|j�|
|��q�WnZttf�y,}z<|jdd�}|jdd
t|�f||_|�WYd}~n
d}~00dS)r�NrMrr�r!z�
                        Data for field %s (%s class, %s method, tag %s) does
                        not match any of the field definitions
                        r	Tr�FrLzU
                        Missing required field "%s" from %s
                        r�)r<r�rhrjrArfr�r�r}r~rGrr�rjr?rrBr�r�r�rxr0rdrtrgrr
r�r1rH)rIr�r4r�r7r�rr�r�r�Z	child_mapr�r�Z
seen_fieldr�r�r�r�r�Ztotal_fieldsr��missingrNrHr)r)r*rgs�





��


�


�
zSet._parse_childrenc	Cs�|jdur|��g}t|j�D]T\}}|j|d�}|j|\}}}d|vrd|fi|����|krdq |�|j|f�q |jdd�d�d�dd	�|D��|_	d|_
|jdkr�d|_dS)
ac
        Encodes all child objects into the contents for this object.

        This method is overridden because a Set needs to be encoded by
        removing defaulted fields and then sorting the fields by tag.

        :param force:
            Ensure all contents are in DER format instead of possibly using
            cached BER-encoded data
        Nr�rMcSs|dSr�r))�ctr)r)r*�<lambda>�r+z#Set._set_contents.<locals>.<lambda>)r�r+cSsg|]}|d�qS)r	r))r�r�r)r)r*r��r+z%Set._set_contents.<locals>.<listcomp>)rfrgr�rZrhr�r2�sortr�r�rr�)	rIr�Zchild_tag_encodingsr�r�Zchild_encodingr�r.r�r)r)r*ro�s

zSet._set_contents)F)F)r�r�r�r�rFrDr2r�r8rgror)r)r)r*r��s
or�c@seZdZdZdZddd�ZdS)�SetOfz~
    Represents a set (unordered) of a single type of values from ASN.1 as a
    Python object with a list-like interface
    r�FcCs\|jdur|��g}|D]}|�|j|d��qd�t|��|_d|_|jdkrXd|_dS)aD
        Encodes all child objects into the contents for this object.

        This method is overridden because a SetOf needs to be encoded by
        sorting the child encodings.

        :param force:
            Ensure all contents are in DER format instead of possibly using
            cached BER-encoded data
        Nr�r+)	rfrgr�rZr�rkr�rr�)rIr�Zchild_encodingsr�r)r)r*ro�s

zSetOf._set_contentsN)F)r�r�r�r�r2ror)r)r)r*r��sr�c@seZdZdZdZdS)�EmbeddedPdvz
    A sequence structure
    �NrYr)r)r)r*r��sr�c@seZdZdZdZdZdS)�
NumericStringzK
    Represents a numeric string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r��sr�c@seZdZdZdZdZdS)�PrintableStringzM
    Represents a printable string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r��sr�c@seZdZdZdZdZdS)�
TeletexStringzK
    Represents a teletex string from ASN.1 as a Python unicode string
    �ZteletexNrar)r)r)r*r��sr�c@seZdZdZdZdS)�VideotexStringzI
    Represents a videotex string from ASN.1 as a Python byte string
    �NrYr)r)r)r*r��sr�c@seZdZdZdZdZdS)�	IA5StringzH
    Represents an IA5 string from ASN.1 as a Python unicode string
    ��asciiNrar)r)r)r*r��sr�c@s(eZdZdZedd��Zedd��ZdS)�AbstractTimezK
    Represents a time from ASN.1 as a Python datetime.datetime object
    c	CsFt|�}|j�|�}|s,ttd|t|����|��}d}|drHtj}nD|dr�|ddkr`dnd}t	|t
t|d�t|d	p�d
�d��}|dr�tt|d�d
t
|d��d}|ddur�|d9}n|ddur�|d9}t|�d��}nd
}t|d�t|d�t|d�t|d�t|d�p*d
�t|d�p:d
�||d�S)z�
        The parsed datetime string.

        :raises:
            ValueError - when an invalid value is passed

        :return:
            A dict with the parsed values
        z:
                Error parsing %s to a %s
                NZzuluZdsign�+r	r}ZdhourZdminuter)�hours�minutes�fractionr^i@B�minutei�second�<�year�month�day�hour)r�r�r�r�r�r��tzinfor�)r�_TIMESTRING_RErKr?rr
�	groupdictr�utcrrrrrAZlimit_denominator)rI�string�m�groups�tz�signZfractZ
fract_usecr)r)r*�_parsed_timesP�
�

��




�zAbstractTime._parsed_timecCsR|jdurdS|jdurL|j}|�dd�}|�|�}|rF|t|d�7}||_|jS)aF
        The native Python datatype representation of this value

        :return:
            A datetime.datetime object, asn1crypto.util.extended_datetime object or
            None. The datetime object is usually timezone aware. If it's naive, then
            it's in the sender's local time; see X.680 sect. 42.3
        Nr�r)�microseconds)rGrnr�r��
_get_datetimer)rIrtr�r6r)r)r*rxFs


zAbstractTime.nativeN)r�r�r�r�r�r�rxr)r)r)r*r�s

?r�c@s2eZdZdZdZe�dej�Zdd�Z	dd�Z
dS)	�UTCTimez^
    Represents a UTC time from ASN.1 as a timezone aware Python datetime.datetime object
    �a

        ^
        # YYMMDD
        (?P<year>\d{2})
        (?P<month>\d{2})
        (?P<day>\d{2})

        # hhmm or hhmmss
        (?P<hour>\d{2})
        (?P<minute>\d{2})
        (?P<second>\d{2})?

        # Matches nothing, needed because GeneralizedTime uses this.
        (?P<fraction>)

        # Z or [-+]hhmm
        (?:
            (?P<zulu>Z)
            |
            (?:
                (?P<dsign>[-+])
                (?P<dhour>\d{2})
                (?P<dminute>\d{2})
            )
        )
        $
    cCspt|t�rZ|jstd��|�t�}d|jkr8dksBntd��|�d�}trZ|�	d�}t
�||�d|_dS)z�
        Sets the value of the object

        :param value:
            A unicode string or a datetime.datetime object

        :raises:
            ValueError - when an invalid value is passed
        �Must be timezone awarei�izMYear of the UTCTime is not in range [1950, 2049], use GeneralizedTime insteadz
%y%m%d%H%M%SZr�N)
r0rr�r?�
astimezonerr��strftimerRr�r�rErnr�r)r)r*rE�s



zUTCTime.setcCs<|ddkr|dd7<n|dd7<tfi|��S)z�
        Create a datetime object from the parsed time.

        :return:
            An aware datetime.datetime object
        r��2i�il)r�rIrtr)r)r*r��szUTCTime._get_datetimeN�r�r�r�r�r2�re�compile�Xr�rEr�r)r)r)r*r�cs�r�c@s2eZdZdZdZe�dej�Zdd�Z	dd�Z
dS)	�GeneralizedTimez�
    Represents a generalized time from ASN.1 as a Python datetime.datetime
    object or asn1crypto.util.extended_datetime object in UTC
    �aO
        ^
        # YYYYMMDD
        (?P<year>\d{4})
        (?P<month>\d{2})
        (?P<day>\d{2})

        # hh or hhmm or hhmmss
        (?P<hour>\d{2})
        (?:
            (?P<minute>\d{2})
            (?P<second>\d{2})?
        )?

        # Optional fraction; [.,]dddd (one or more decimals)
        # If Seconds are given, it's fractions of Seconds.
        # Else if Minutes are given, it's fractions of Minutes.
        # Else it's fractions of Hours.
        (?:
            [,.]
            (?P<fraction>\d+)
        )?

        # Optional timezone. If left out, the time is in local time.
        # Z or [-+]hh or [-+]hhmm
        (?:
            (?P<zulu>Z)
            |
            (?:
                (?P<dsign>[-+])
                (?P<dhour>\d{2})
                (?P<dminute>\d{2})?
            )
        )?
        $
    cCs�t|ttf�rl|jstd��|�t�}|jrHdt|j��	d��
d�}nd}|�d�|d}trl|�
d�}t�||�d	|_d	S)
a
        Sets the value of the object

        :param value:
            A unicode string, a datetime.datetime object or an
            asn1crypto.util.extended_datetime object

        :raises:
            ValueError - when an invalid value is passed
        r�rMrFrr�z%Y%m%d%H%M%S�Zr�N)r0rrr�r?r�r�microsecond�str�zfillrr�rRr�r�rErn)rIr6r�r)r)r*rE�s

zGeneralizedTime.setcCs,|ddkrtfi|��Stfi|��SdS)z�
        Create a datetime object from the parsed time.

        :return:
            A datetime.datetime object or asn1crypto.util.extended_datetime object.
            It may or may not be aware.
        r�rN)rrr�r)r)r*r�s	zGeneralizedTime._get_datetimeNr�r)r)r)r*r��s#�%!r�c@seZdZdZdZdZdS)�
GraphicStringzK
    Represents a graphic string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r�sr�c@seZdZdZdZdZdS)�
VisibleStringzK
    Represents a visible string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r�"sr�c@seZdZdZdZdZdS)�
GeneralStringzK
    Represents a general string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r�+sr�c@seZdZdZdZdZdS)�UniversalStringzM
    Represents a universal string from ASN.1 as a Python unicode string
    �z	utf-32-beNrar)r)r)r*r�5sr�c@seZdZdZdZdZdS)�CharacterStringzM
    Represents a character string from ASN.1 as a Python unicode string
    �r�Nrar)r)r)r*r�>sr�c@seZdZdZdZdZdS)�	BMPStringzG
    Represents a BMP string from ASN.1 as a Python unicode string
    �z	utf-16-beNrar)r)r)r*r�Hsr�cCs\td|t|�t|�f�|jrBtd|t�|jp2d��d�f�|jduo^|jduo^|j	du}|r|t
�|j�}t�|j�}|j
dur�|j
D] \}}td|t�|�|f�q�|r�td||||j	f�n>|jr�|r�td||||j	f�n|�rtd	||||j	f�|j�r4td
|t�|j�p$d��d�f�td|t�|j�pHd��d�f�dS)a7
    Prints out basic information about an Asn1Value object. Extracted for reuse
    among different classes that customize the debug information.

    :param prefix:
        A unicode string of spaces to prefix output line with

    :param self:
        The object to print the debugging information about
    r�z%s  Header: 0x%sr+r\Nz#%s    %s tag %s (explicitly tagged)z%s      %s %s %sz&%s    %s %s tag %s (implicitly tagged)z%s    %s %s tag %sz%s  Trailer: 0x%sz%s  Data: 0x%s)ryr
rYr�binascii�hexlifyr�rFrDr2r�rjrBr9r:r�rG)r{rI�
has_header�method_name�
class_namerDr2r)r)r*rvQs6"
���$rvcCspd|vrl|ddkr.|�dd�|df|d<n$|ddkrR|�dd�|df|d<|d=|d=d|vrl|d=dS)z�
    Converts old-style "tag_type" and "tag" params to "explicit" and "implicit"

    :param params:
        A dict of parameters to convert from tag_type/tag to explicit/implicit
    rKr9�classr!r2r:N)rj)r�r)r)r*r��sr�cCs�t|�d}d|vr$|jdurxd}nTt|dt�r@|d\}}n|d}d}|jdur\d}n|jt|kst|j|krxd}|�d�|jkr�d}|r�|�	|�S|S)z�
    Checks if a value is properly tagged based on the spec, and re/untags as
    necessary

    :param value:
        An Asn1Value object

    :param params:
        A dict of spec params

    :return:
        An Asn1Value that is properly tagged
    Fr:Trr9)
r�r:r0r�rDrCr2rjr9rk)r6r�rkrDr2r)r)r*r��s$


r�cCs�|durdS|j}|j}t|�d|vrRt|dt�rD|d\}}q�d}|d}n0d|vr�t|dt�rv|d\}}nd}|d}|dur�t|t�s�t|}|�d|�}|�d|�}||fS)aP
    Builds a 2-element tuple used to identify fields by grabbing the class_
    and tag from an Asn1Value class and the params dict being passed to it

    :param params:
        A dict of params to pass to spec

    :param spec:
        An Asn1Value class

    :return:
        A 2-element integer tuple in the form (class_, tag)
    N)NNr9r!r:rDr2)rDr2r�r0r�rrCrj)r�r.Zrequired_classZrequired_tagr)r)r*r��s(
r�cCsJ|s|sdStttt|d�|����}t|�|krFtd�t|�|���|S)z�
    Format value as a tuple of 1s and 0s.

    :param value:
        A non-negative integer to format

    :param bits:
        Number of bits in the output

    :return:
        A tuple of 1s and 0s with bits members.
    r)z0{0}bzResult too large: {0} > {1})r�rrrrAr?)r6r�resultr)r)r*r�sr)r	r!rr7rCrFrrr\r^r�r`rcrer�r�r�r�r�r�r�r�r�r�r�r�r�r�c	
Cs
|durt|�|durtSd}	|du�r@|o4d|v}
|
�s�|jsR|�r�d|v�r�|rf|fi|��}n|�}|j}t|�}
|}|}|}|}|}|p�d}|
D]�\}}||kr�ttdt|�t�|�t�||����|dkr�ttdt|�t	�d�t	�||����||k�rttd	t|�||���t
|t|��\}}|\}}}}}}t|t
�s�||7}||}q�t||dd
id��}||_||_||_d
}	�qx|�r�|fd|i|��}n
||d
�}|tu�r��qxt|t
��rL|�|||�z||j|_d}|��WnZttf�yH}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00n�||jk�r~ttdt|�t�|j�t�||����||jk�r�|dk�o�|jdk�o�|dk}|�r�t|t��s�ttdt|�t	�|j�t	�||����n||_d
|_||jk�rxt|jt��r||jv}n
||jk}|�sxttdt|�|j|����n8|�rd|v�rtfd|i|��}|j}|}|}|�pxd}t|�D]<\}}t
|t|��\}}|\}}}}}}||7}||}�q�t||dd
id��}||j|_|j|�p�d7_||_d
}	nx|tv�r(ttdt�|�t	�|�|���t|}|||d�}|dk�oX|jdk�oX|dk}|�rrt|t��rrd
|_||_|	�s�||_|�p�d|_d|_ |�rz|�|�WnZttf�y}z<|jdd�}|jddt|�f||_|�WYd}~n
d}~00|S)a
    Builds an Asn1Value object generically, or using a spec with optional params

    :param class_:
        An integer representing the ASN.1 class

    :param method:
        An integer representing the ASN.1 method

    :param tag:
        An integer representing the ASN.1 tag

    :param header:
        A byte string of the ASN.1 header (class, method, tag, length)

    :param contents:
        A byte string of the ASN.1 value

    :param trailer:
        A byte string of any ASN.1 trailer (only used by indefinite length encodings)

    :param spec:
        A class derived from Asn1Value that defines what class_ and tag the
        value should have, and the semantics of the encoded value. The
        return value will be of this type. If omitted, the encoded value
        will be decoded using the standard universal tag based on the
        encoded tag number.

    :param spec_params:
        A dict of params to pass to the spec object

    :param nested_spec:
        For certain Asn1Value classes (such as OctetString and BitString), the
        contents can be further parsed and interpreted as another Asn1Value.
        This parameter controls the spec for that sub-parsing.

    :return:
        An object of the type spec, or if not specified, a child of Asn1Value
    NFrJr9r+z�
                        Error parsing %s - explicitly-tagged class should have been
                        %s, but %s was found
                        r	z�
                        Error parsing %s - explicitly-tagged method should have
                        been %s, but %s was found
                        z�
                        Error parsing %s - explicitly-tagged tag should have been
                        %s, but %s was found
                        Tr�rGr�rr�z�
                        Error parsing %s - class should have been %s, but %s was
                        found
                        szy
                            Error parsing %s - method should have been %s, but %s was found
                            zv
                            Error parsing %s - tag should have been %s, but %s was found
                            zO
                Unknown element - %s class, %s method, tag %s
                )rGrD)!r�rjr9�reversedr?rr
rBrjr�rrAr0r�rxrr�r�r�rGr�r1rHrDrFr�r�r2r�r�r&�_UNIVERSAL_SPECSrn)rDrFr2r�rG�trailerr.r/Znested_specZ
header_setrJr6Zoriginal_explicitZ
explicit_infoZparsed_classZ
parsed_methodZ
parsed_tagZto_parseZexplicit_headerZexplicit_trailerZexpected_classZexpected_tagr�r7Z
parsed_headerZparsed_trailerrNrHZ	ber_indefZ
is_bad_tag�original_valuer)r)r*rx s)

�	
�	
�	





�	

�	
�


�	rxc	CsTt|�}t|||�\}}|r@|||kr@|||}td|��t|||d��|fS)a�
    Parses a byte string generically, or using a spec with optional params

    :param encoded_data:
        A byte string that contains BER-encoded data

    :param pointer:
        The index in the byte string to parse from

    :param spec:
        A class derived from Asn1Value that defines what class_ and tag the
        value should have, and the semantics of the encoded value. The
        return value will be of this type. If omitted, the encoded value
        will be decoded using the standard universal tag based on the
        encoded tag number.

    :param spec_params:
        A dict of params to pass to the spec object

    :param strict:
        A boolean indicating if trailing data should be forbidden - if so, a
        ValueError will be raised when trailing data exists

    :return:
        A 2-element tuple:
         - 0: An object of the type spec, or if not specified, a child of Asn1Value
         - 1: An integer indicating how many bytes were consumed
    r�r�)rArr?rx)	r(r�r.r/r%Zencoded_lenr�Znew_pointerr�r)r)r*r3	sr3)F)NNN)rNNF)nr��
__future__rrrrrr�	fractionsrr�rbrr��sysr�r
�_errorsrZ_ordereddictr�_typesr
rrrr�parserrr�utilrrrrrr�version_info�	cStringIOrr�xrangerrR�io�registerrBrCr�r�rJr=r'�objectr&r�r�r�r�rjr�r�r�r�r�r�r�r�rr$r0r6r<r@rArBrDrXrZr[r]r_rbrdrtr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rvr�r�r�rr�rxr3r)r)r)r*�<module>s*. 
���

6e,Q6V#Q5QlANQ34bD		CJ;!				bV_
	
	
	/(-� 
j