o
    e|                     @   s   d dl Z d dlmZmZmZmZ d dlmZmZ g dZ	dddZ
G dd	 d	eZG d
d deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZG dd deZdS )    N)byte_stringbbchrbord)long_to_bytesbytes_to_long)	DerObject
DerIntegerDerOctetStringDerNullDerSequenceDerObjectIdDerBitStringDerSetOfFc                 C   s4   d}z| | }W n
 t y   Y dS w | p| dkS )Nr   F)	TypeError)xonly_non_negativetest r   6/usr/lib/python3/dist-packages/Cryptodome/Util/asn1.py
_is_number!   s   r   c                   @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )BytesIO_EOFzeThis class differs from BytesIO in that a ValueError exception is
    raised whenever EOF is reached.c                 C   s   || _ d| _d | _d S Nr   )_buffer_index	_bookmark)selfinitial_bytesr   r   r   __init__.   s   
zBytesIO_EOF.__init__c                 C   s   | j | _d S N)r   r   r   r   r   r   set_bookmark3      zBytesIO_EOF.set_bookmarkc                 C   s    | j d usJ | j| j | j S r   )r   r   r   r    r   r   r   data_since_bookmark6   s   zBytesIO_EOF.data_since_bookmarkc                 C   s   t | j| j S r   )lenr   r   r    r   r   r   remaining_data:      zBytesIO_EOF.remaining_datac                 C   sH   | j | }|t| jkrtd|t| jf | j| j | }|| _ |S )Nz@Not enough data for DER decoding: expected %d bytes and found %d)r   r$   r   
ValueError)r   length	new_indexresultr   r   r   read=   s   
zBytesIO_EOF.readc                 C   s   t | dd S )N   r   )r   r+   r    r   r   r   	read_byteF      zBytesIO_EOF.read_byteN)
__name__
__module____qualname____doc__r   r!   r#   r%   r+   r-   r   r   r   r   r   *   s    	r   c                   @   sT   e Zd ZdZ		dddZdd Zed	d
 Zdd Zdd Z	dddZ
dd ZdS )r   zpBase class for defining a single DER object.

        This class should never be directly instantiated.
        N    Fc                 C   s   |du r	d| _ dS | |}|| _d||fvrtd|dur-dd| B | |B | _ dS |durBd| |B | _ d| |B | _dS d| |B | _ dS )a  Initialize the DER object according to a specific ASN.1 type.

                :Parameters:
                  asn1Id : integer
                    The universal DER tag number for this object
                    (e.g. 0x10 for a SEQUENCE).
                    If None, the tag is not known yet.

                  payload : byte string
                    The initial payload of the object (that it,
                    the content octets).
                    If not specified, the payload is empty.

                  implicit : integer
                    The IMPLICIT tag number to use for the encoded object.
                    It overrides the universal tag *asn1Id*.

                  constructed : bool
                    True when the ASN.1 type is *constructed*.
                    False when it is *primitive*.

                  explicit : integer
                    The EXPLICIT tag number to use for the encoded object.
                Nz1Explicit and implicit tags are mutually exclusive          )
_tag_octet_convertTagpayloadr'   _inner_tag_octet)r   asn1Idr9   implicitconstructedexplicitr   r   r   r   P   s   
zDerObject.__init__c                 C   sP   t |st|dkrt|d }t |r"d|  kr!dk s&td td|S )zvCheck if *tag* is a real DER tag.
                Convert it from a character to number if necessary.
                r,   r      zWrong DER tag)r   r$   r   r'   )r   tagr   r   r   r8      s   zDerObject._convertTagc                 C   s,   | dkrt | }tt|d | S t| S )zXBuild length octets according to BER/DER
                definite form.
                   r4   )r   r   r$   )r(   encodingr   r   r   _definite_form   s   zDerObject._definite_formc                 C   sL   | j }t| drt| j| t| j  | j  }t| j| t| | S )z?Return this DER element, fully encoded as a binary byte string.r:   )r9   hasattrr   r:   rC   r$   r7   )r   output_payloadr   r   r   encode   s   
zDerObject.encodec                 C   sR   |  }|dkr'||d@ }t|d dkrtdt|}|dkr'td|S )z%Decode DER length octets from a file.rA   r   z$Invalid DER: length has leading zeroz5Invalid DER: length in long form but smaller than 128)r-   r+   r   r'   r   )r   sr(   encoded_lengthr   r   r   
_decodeLen   s   zDerObject._decodeLenc                 C   s<   t |stdt|}| || | dkrtd| S )a  Decode a complete DER element, and re-initializes this
                object with it.

                Args:
                  der_encoded (byte string): A complete DER element.

                Raises:
                  ValueError: in case of parsing errors.
                zInput is not a byte stringr   -Unexpected extra data after the DER structure)r   r'   r   _decodeFromStreamr%   )r   der_encodedstrictrG   r   r   r   decode   s   zDerObject.decodec                 C   s   |  }| jdur|| jkrtdn|| _| |}||| _t| drMt| j}|  }|| jkr8td| |}||| _|	 dkrOtddS dS )z*Decode a complete DER element from a file.NzUnexpected DER tagr:   zUnexpected internal DER tagr   rJ   )
r-   r7   r'   rI   r+   r9   rD   r   r:   r%   )r   rG   rM   idOctetr(   pinner_octetr   r   r   rK      s&   






	zDerObject._decodeFromStream)Nr3   NFNF)r/   r0   r1   r2   r   r8   staticmethodrC   rF   rI   rN   rK   r   r   r   r   r   J   s    
?
	
r   c                   @   4   e Zd ZdZdddZdd Zdd	d
Zdd ZdS )r	   a  Class to model a DER INTEGER.

        An example of encoding is::

          >>> from Cryptodome.Util.asn1 import DerInteger
          >>> from binascii import hexlify, unhexlify
          >>> int_der = DerInteger(9)
          >>> print hexlify(int_der.encode())

        which will show ``020109``, the DER encoding of 9.

        And for decoding::

          >>> s = unhexlify(b'020109')
          >>> try:
          >>>   int_der = DerInteger()
          >>>   int_der.decode(s)
          >>>   print int_der.value
          >>> except ValueError:
          >>>   print "Not a valid DER INTEGER"

        the output will be ``9``.

        :ivar value: The integer value
        :vartype value: integer
        r   Nc                 C      t | dd|d| || _dS )aU  Initialize the DER object as an INTEGER.

                :Parameters:
                  value : integer
                    The value of the integer.

                  implicit : integer
                    The IMPLICIT tag to use for the encoded object.
                    It overrides the universal tag for INTEGER (2).
                   r3   FNr   r   valuer   rX   r<   r>   r   r   r   r     s   
zDerInteger.__init__c                 C   s|   | j }d| _	 tt|d@ | j | _d|  krdkr'n ntd| j | _d|  kr1dkr4n nn|dL }qt| S )zIReturn the DER INTEGER, fully encoded as a
                binary string.r3   T   r4   r   i   )rX   r9   r   intr   rF   )r   numberr   r   r   rF   %  s   
zDerInteger.encodeFc                 C   s   t j| ||dS )a!  Decode a complete DER INTEGER DER, and re-initializes this
                object with it.

                Args:
                  der_encoded (byte string): A complete INTEGER DER element.

                Raises:
                  ValueError: in case of parsing errors.
                rM   r   rN   r   rL   rM   r   r   r   rN   4  s   zDerInteger.decodec                 C   s   t | || |r.t| jdkrtdt| jdkr.td| jdd d dk r.tdd| _d}| jD ]}|  jd	9  _|  jt|7  _|d
K }q6| jrbt| jd d@ rd|  j|8  _dS dS dS )z*Decode a complete DER INTEGER from a file.r   z/Invalid encoding for DER INTEGER: empty payloadrV   z>HNr4   z.Invalid encoding for DER INTEGER: leading zeror,      r[   )	r   rK   r$   r9   r'   structunpackrX   r   )r   rG   rM   bitsir   r   r   rK   A  s   ,

zDerInteger._decodeFromStream)r   NNrR   r/   r0   r1   r2   r   rF   rN   rK   r   r   r   r   r	      s    

r	   c                   @   s   e Zd ZdZd#ddZdd Zdd Zd	d
 Zdd Zdd Z	dd Z
dd Zdd Zdd Zd$ddZd$ddZdd Zd%dd Zd!d" ZdS )&r   a  Class to model a DER SEQUENCE.

        This object behaves like a dynamic Python sequence.

        Sub-elements that are INTEGERs behave like Python integers.

        Any other sub-element is a binary string encoded as a complete DER
        sub-element (TLV).

        An example of encoding is:

          >>> from Cryptodome.Util.asn1 import DerSequence, DerInteger
          >>> from binascii import hexlify, unhexlify
          >>> obj_der = unhexlify('070102')
          >>> seq_der = DerSequence([4])
          >>> seq_der.append(9)
          >>> seq_der.append(obj_der.encode())
          >>> print hexlify(seq_der.encode())

        which will show ``3009020104020109070102``, the DER encoding of the
        sequence containing ``4``, ``9``, and the object with payload ``02``.

        For decoding:

          >>> s = unhexlify(b'3009020104020109070102')
          >>> try:
          >>>   seq_der = DerSequence()
          >>>   seq_der.decode(s)
          >>>   print len(seq_der)
          >>>   print seq_der[0]
          >>>   print seq_der[:]
          >>> except ValueError:
          >>>   print "Not a valid DER SEQUENCE"

        the output will be::

          3
          4
          [4, 9, b'']

        Nc                 C   s.   t | dd|d |du rg | _dS || _dS )a  Initialize the DER object as a SEQUENCE.

                :Parameters:
                  startSeq : Python sequence
                    A sequence whose element are either integers or
                    other DER objects.

                  implicit : integer
                    The IMPLICIT tag to use for the encoded object.
                    It overrides the universal tag for SEQUENCE (16).
                   r3   TN)r   r   _seq)r   startSeqr<   r   r   r   r     s   

zDerSequence.__init__c                 C   s   | j |= d S r   rh   r   nr   r   r   __delitem__  r"   zDerSequence.__delitem__c                 C   
   | j | S r   rj   rk   r   r   r   __getitem__     
zDerSequence.__getitem__c                 C   s   || j |< d S r   rj   )r   keyrX   r   r   r   __setitem__  s   zDerSequence.__setitem__c                 C   s   || j ||< d S r   rj   )r   re   jsequencer   r   r   __setslice__  r.   zDerSequence.__setslice__c                 C   s   | j ||= d S r   rj   r   re   rs   r   r   r   __delslice__  r&   zDerSequence.__delslice__c                 C   s   | j td|td| S r   )rh   maxrv   r   r   r   __getslice__  s   zDerSequence.__getslice__c                 C   
   t | jS r   r$   rh   r    r   r   r   __len__  rp   zDerSequence.__len__c                 C      | j | | S r   rh   appendr   itemr   r   r   __iadd__     zDerSequence.__iadd__c                 C   r}   r   r~   r   r   r   r   r     r   zDerSequence.appendTc                    s    fdd| j D }t|S )zReturn the number of items in this sequence that are
                integers.

                Args:
                  only_non_negative (boolean):
                    If ``True``, negative integers are not counted in.
                c                    s   g | ]	}t | r|qS r   )r   .0r   r   r   r   
<listcomp>  s    z'DerSequence.hasInts.<locals>.<listcomp>)rh   r$   )r   r   itemsr   r   r   hasInts  s   	zDerSequence.hasIntsc                 C   s   | j o| |t| j kS )a  Return ``True`` if all items in this sequence are integers
                or non-negative integers.

                This function returns False is the sequence is empty,
                or at least one member is not an integer.

                Args:
                  only_non_negative (boolean):
                    If ``True``, the presence of negative integers
                    causes the method to return ``False``.)rh   r   r$   )r   r   r   r   r   hasOnlyInts  s   zDerSequence.hasOnlyIntsc                 C   sf   d| _ | jD ]'}t|r|  j |7  _ qt|r$|  j t| 7  _ q|  j | 7  _ qt| S )zReturn this DER SEQUENCE, fully encoded as a
                binary string.

                Raises:
                  ValueError: if some elements in the sequence are neither integers
                              nor byte strings.
                r3   )r9   rh   r   r   r	   rF   r   r   r   r   r   rF     s   

zDerSequence.encodeFc                 C   s.   || _ tj| ||d}|r|  std|S )a9  Decode a complete DER SEQUENCE, and re-initializes this
                object with it.

                Args:
                  der_encoded (byte string):
                    A complete SEQUENCE DER element.
                  nr_elements (None or integer or list of integers):
                    The number of members the SEQUENCE can have
                  only_ints_expected (boolean):
                    Whether the SEQUENCE is expected to contain only integers.
                  strict (boolean):
                    Whether decoding must check for strict DER compliancy.

                Raises:
                  ValueError: in case of parsing errors.

                DER INTEGERs are decoded into Python integers. Any other DER
                element is not decoded. Its validity is not checked.
                r^   zSome members are not INTEGERs)_nr_elementsr   rN   r   r'   )r   rL   rM   nr_elementsonly_ints_expectedr*   r   r   r   rN     s
   zDerSequence.decodec                 C   s   g | _ t| || t| j}| dkrK|  t }||| |jdkr0| j |	  nt
 }|	 }|j||d | j |j | dksd}| jdurnz
t| j | jv }W n tym   t| j | jk}Y nw |sytdt| j  dS )z+Decode a complete DER SEQUENCE from a file.r   rV   r^   TNz1Unexpected number of members (%d) in the sequence)rh   r   rK   r   r9   r%   r!   r7   r   r#   r	   rN   rX   r   r$   r   r'   )r   rG   rM   rP   derderIntdataokr   r   r   rK     s4   


zDerSequence._decodeFromStreamNN)T)FNF)r/   r0   r1   r2   r   rm   ro   rr   ru   rw   ry   r|   r   r   r   r   rF   rN   rK   r   r   r   r   r   X  s"    
*


r   c                   @   s   e Zd ZdZdddZdS )r
   a  Class to model a DER OCTET STRING.

    An example of encoding is:

    >>> from Cryptodome.Util.asn1 import DerOctetString
    >>> from binascii import hexlify, unhexlify
    >>> os_der = DerOctetString(b'\xaa')
    >>> os_der.payload += b'\xbb'
    >>> print hexlify(os_der.encode())

    which will show ``0402aabb``, the DER encoding for the byte string
    ``b'\xAA\xBB'``.

    For decoding:

    >>> s = unhexlify(b'0402aabb')
    >>> try:
    >>>   os_der = DerOctetString()
    >>>   os_der.decode(s)
    >>>   print hexlify(os_der.payload)
    >>> except ValueError:
    >>>   print "Not a valid DER OCTET STRING"

    the output will be ``aabb``.

    :ivar payload: The content of the string
    :vartype payload: byte string
    r3   Nc                 C   s   t | d||d dS )ah  Initialize the DER object as an OCTET STRING.

        :Parameters:
          value : byte string
            The initial payload of the object.
            If not specified, the payload is empty.

          implicit : integer
            The IMPLICIT tag to use for the encoded object.
            It overrides the universal tag for OCTET STRING (4).
           FNr   r   )r   rX   r<   r   r   r   r   A  s   zDerOctetString.__init__)r3   Nr/   r0   r1   r2   r   r   r   r   r   r
   #  s    r
   c                   @   s   e Zd ZdZdd ZdS )r   z"Class to model a DER NULL element.c                 C   s   t | dddd dS )z$Initialize the DER object as a NULL.   r3   NFr   r    r   r   r   r   S  s   zDerNull.__init__Nr   r   r   r   r   r   P  s    r   c                   @   rT   )r   a,  Class to model a DER OBJECT ID.

    An example of encoding is:

    >>> from Cryptodome.Util.asn1 import DerObjectId
    >>> from binascii import hexlify, unhexlify
    >>> oid_der = DerObjectId("1.2")
    >>> oid_der.value += ".840.113549.1.1.1"
    >>> print hexlify(oid_der.encode())

    which will show ``06092a864886f70d010101``, the DER encoding for the
    RSA Object Identifier ``1.2.840.113549.1.1.1``.

    For decoding:

    >>> s = unhexlify(b'06092a864886f70d010101')
    >>> try:
    >>>   oid_der = DerObjectId()
    >>>   oid_der.decode(s)
    >>>   print oid_der.value
    >>> except ValueError:
    >>>   print "Not a valid DER OBJECT ID"

    the output will be ``1.2.840.113549.1.1.1``.

    :ivar value: The Object ID (OID), a dot separated list of integers
    :vartype value: string
     Nc                 C   rU   )a  Initialize the DER object as an OBJECT ID.

        :Parameters:
          value : string
            The initial Object Identifier (e.g. "1.2.0.0.6.2").
          implicit : integer
            The IMPLICIT tag to use for the encoded object.
            It overrides the universal tag for OBJECT ID (6).
          explicit : integer
            The EXPLICIT tag to use for the encoded object.
           r3   FNrW   rY   r   r   r   r   w  s   
zDerObjectId.__init__c                 C   s   dd | j dD }t|dk rtdtd|d  |d  | _|dd	 D ]5}|dkr2dg}ng }|rF|d|d
@ dB  |dL }|s6|d  d
M  < |  jddd |D 7  _q(t	| S )zCReturn the DER OBJECT ID, fully encoded as a
        binary string.c                 S      g | ]}t |qS r   )r\   r   r   r   r   r         z&DerObjectId.encode.<locals>.<listcomp>.rV   z$Not a valid Object Identifier string(   r   r,   NrA   r4      r3   c                 S   r   r   )r   r   r   r   r   r     r   )
rX   splitr$   r'   r   r9   insertjoinr   rF   )r   compsvencr   r   r   rF     s    
zDerObjectId.encodeFc                 C      t | ||S )ab  Decode a complete DER OBJECT ID, and re-initializes this
        object with it.

        Args:
            der_encoded (byte string):
                A complete DER OBJECT ID.
            strict (boolean):
                Whether decoding must check for strict DER compliancy.

        Raises:
            ValueError: in case of parsing errors.
        r_   r`   r   r   r   rN     s   zDerObjectId.decodec                 C   s   t | || t| j}dd t| dD }d}| r;| }|d |d@  }|d@ s7|t| d}| sd	|| _
dS )	z,Decode a complete DER OBJECT ID from a file.c                 S   r   r   )strr   r   r   r   r     r   z1DerObjectId._decodeFromStream.<locals>.<listcomp>r   r   r4   rA   r   N)r   rK   r   r9   divmodr-   r%   r   r   r   rX   )r   rG   rM   rP   r   r   cr   r   r   rK     s   
zDerObjectId._decodeFromStream)r   NNrR   rf   r   r   r   r   r   Y  s    

r   c                   @   rT   )r   a  Class to model a DER BIT STRING.

    An example of encoding is:

    >>> from Cryptodome.Util.asn1 import DerBitString
    >>> from binascii import hexlify, unhexlify
    >>> bs_der = DerBitString(b'\xaa')
    >>> bs_der.value += b'\xbb'
    >>> print hexlify(bs_der.encode())

    which will show ``040300aabb``, the DER encoding for the bit string
    ``b'\xAA\xBB'``.

    For decoding:

    >>> s = unhexlify(b'040300aabb')
    >>> try:
    >>>   bs_der = DerBitString()
    >>>   bs_der.decode(s)
    >>>   print hexlify(bs_der.value)
    >>> except ValueError:
    >>>   print "Not a valid DER BIT STRING"

    the output will be ``aabb``.

    :ivar value: The content of the string
    :vartype value: byte string
    r3   Nc                 C   s6   t | dd|d| t|t r| | _dS || _dS )a  Initialize the DER object as a BIT STRING.

        :Parameters:
          value : byte string or DER object
            The initial, packed bit string.
            If not specified, the bit string is empty.
          implicit : integer
            The IMPLICIT tag to use for the encoded object.
            It overrides the universal tag for OCTET STRING (3).
          explicit : integer
            The EXPLICIT tag to use for the encoded object.
           r3   FN)r   r   
isinstancerF   rX   rY   r   r   r   r     s   

zDerBitString.__init__c                 C   s   d| j  | _t| S )zDReturn the DER BIT STRING, fully encoded as a
        binary string.    )rX   r9   r   rF   r    r   r   r   rF     s   
zDerBitString.encodeFc                 C   r   )aT  Decode a complete DER BIT STRING, and re-initializes this
        object with it.

        Args:
            der_encoded (byte string): a complete DER BIT STRING.
            strict (boolean):
                Whether decoding must check for strict DER compliancy.

        Raises:
            ValueError: in case of parsing errors.
        r_   r`   r   r   r   rN     s   zDerBitString.decodec                 C   sR   t | || | jrt| jd dkrtdd| _| jr'| jdd | _dS dS )z1Decode a complete DER BIT STRING DER from a file.r   zNot a valid BIT STRINGr3   r,   N)r   rK   r9   r   r'   rX   )r   rG   rM   r   r   r   rK     s   zDerBitString._decodeFromStream)r3   NNrR   rf   r   r   r   r   r     s    

r   c                   @   sT   e Zd ZdZdddZdd Zdd Zd	d
 Zdd ZdddZ	dd Z
dd ZdS )r   a  Class to model a DER SET OF.

    An example of encoding is:

    >>> from Cryptodome.Util.asn1 import DerBitString
    >>> from binascii import hexlify, unhexlify
    >>> so_der = DerSetOf([4,5])
    >>> so_der.add(6)
    >>> print hexlify(so_der.encode())

    which will show ``3109020104020105020106``, the DER encoding
    of a SET OF with items 4,5, and 6.

    For decoding:

    >>> s = unhexlify(b'3109020104020105020106')
    >>> try:
    >>>   so_der = DerSetOf()
    >>>   so_der.decode(s)
    >>>   print [x for x in so_der]
    >>> except ValueError:
    >>>   print "Not a valid DER SET OF"

    the output will be ``[4, 5, 6]``.
    Nc                 C   s>   t | dd|d g | _d| _|r|D ]	}| | qdS dS )a9  Initialize the DER object as a SET OF.

        :Parameters:
          startSet : container
            The initial set of integers or DER encoded objects.
          implicit : integer
            The IMPLICIT tag to use for the encoded object.
            It overrides the universal tag for SET OF (17).
           r3   TN)r   r   rh   
_elemOctetadd)r   startSetr<   er   r   r   r   2  s   
zDerSetOf.__init__c                 C   rn   r   rj   rk   r   r   r   ro   G  rp   zDerSetOf.__getitem__c                 C   rz   r   )iterrh   r    r   r   r   __iter__J  rp   zDerSetOf.__iter__c                 C   rz   r   r{   r    r   r   r   r|   M  rp   zDerSetOf.__len__c                 C   sl   t |rd}nt|tr| j}nt|d }| j|kr'| jdur$td|| _|| jvr4| j| dS dS )zAdd an element to the set.

        Args:
            elem (byte string or integer):
              An element of the same type of objects already in the set.
              It can be an integer or a DER encoded object.
        rV   r   Nz&New element does not belong to the set)	r   r   r   r7   r   r   r'   rh   r   )r   elemeor   r   r   r   P  s   	



zDerSetOf.addFc                 C   r   )a  Decode a complete SET OF DER element, and re-initializes this
        object with it.

        DER INTEGERs are decoded into Python integers. Any other DER
        element is left undecoded; its validity is not checked.

        Args:
            der_encoded (byte string): a complete DER BIT SET OF.
            strict (boolean):
                Whether decoding must check for strict DER compliancy.

        Raises:
            ValueError: in case of parsing errors.
        r_   r`   r   r   r   rN   h  s   zDerSetOf.decodec                 C   s   g | _ t| || t| j}d}| dkr\|  t }||| |dk r,|j}n	||jkr5td|dkrB| j 	|
  nt }||
 | | j 	|j | dksdS dS )z)Decode a complete DER SET OF from a file.r   r   z)Not all elements are of the same DER typerV   N)rh   r   rK   r   r9   r%   r!   r7   r'   r   r#   r	   rN   rX   )r   rG   rM   rP   
setIdOctetr   r   r   r   r   rK   z  s$   

zDerSetOf._decodeFromStreamc                 C   sf   g }| j D ]}t|rt| }nt|tr| }n|}|| q|  d|| _	t| S )zRReturn this SET OF DER element, fully encoded as a
        binary string.
        r3   )
rh   r   r	   rF   r   r   r   sortr   r9   )r   orderedr   bysr   r   r   rF     s   



zDerSetOf.encoder   rR   )r/   r0   r1   r2   r   ro   r   r|   r   rN   rK   rF   r   r   r   r   r     s    

!r   rR   )rb   Cryptodome.Util.py3compatr   r   r   r   Cryptodome.Util.numberr   r   __all__r   objectr   r   r	   r   r
   r   r   r   r   r   r   r   r   <module>   s    
	  0_ L-	dZ