a
    db9                     @   s  d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm	Z	m
Z
mZmZ ddlmZ ddlmZ dZeje Zd	Zd
Zejdkrdd Zndd Zejdk rdd Zndd Zdd ZdAddZG dd dZdd Zdd Zdd Zefdd Zefd!d"Z d#d$ Z!d%d& Z"d'd( Z#d)d* Z$d+d, Z%d-d. Z&d/d0 Z'd1d2 Z(d3d4 Z)d5d6 Z*d7d8 Z+G d9d: d:e,Z-d;d< Z.d=d> Z/d?d@ Z0dS )B    )divisionN)sha256)PY2int2bytebnext   )der)normalise_bytes)r      iH  i='  r   r   )r         r      )r   r   r   r      )r   c                 C   s&   t t| ddd t| d S )-Convert a bytestring to string of 0's and 1'sbigr   N   )binint
from_byteszfilllenent_256 r   [/home/tom/ab/renpy-build/tmp/install.linux-x86_64/lib/python3.9/site-packages/ecdsa/util.pyentropy_to_bits&   s    r   c                 C   s   d dd | D S )r    c                 s   s(   | ] }t t|d d dV  qdS )r   Nr   )r   ordr   ).0xr   r   r   	<genexpr>/       z"entropy_to_bits.<locals>.<genexpr>)joinr   r   r   r   r   -   s    )r      c                 C   s   t t| d S Nr   )r   r   r    r   r   r   
bit_length4   s    r'   c                 C   s   |   p
dS Nr   )r'   r&   r   r   r   r'   :   s    c                 C   s   dt d|   d S )Nr   z%xr   )r   )orderr   r   r   orderlen>   s    r*   c                 C   s|   | dksJ |du rt j}t| d }|d d }||}t|}t|d| ddd }d|  k rn| k r2n q2|S q2dS )a  Return a random integer k such that 1 <= k < order, uniformly
    distributed across that range. Worst case should be a mean of 2 loops at
    (2**k)+2.

    Note that this function is not declared to be forwards-compatible: we may
    change the behavior in future releases. The entropy= argument (which
    should get a callable that behaves like os.urandom) can be used to
    achieve stability within a given release (for repeatable unit tests), but
    should not be used as a long-term-compatible key generation algorithm.
    r   Nr   r   )baser   )osurandomr'   r   r   )r)   ZentropyZupper_2Z	upper_256r   Zent_2Zrand_numr   r   r   	randrangeB   s    r.   c                   @   s$   e Zd Zdd Zdd Zdd ZdS )PRNGc                 C   s   |  || _d S N)block_generator	generator)selfseedr   r   r   __init__`   s    zPRNG.__init__c                    s0    fddt |D }tr$d|S t|S d S )Nc                    s   g | ]}t  jqS r   )r   r2   )r   ir3   r   r   
<listcomp>d   r"   z!PRNG.__call__.<locals>.<listcomp>r   )ranger   r#   bytes)r3   numbytesar   r7   r   __call__c   s    
zPRNG.__call__c                 c   s6   d}t d||f   D ]
}|V  q|d7 }qd S )Nr   z
prng-%d-%sr   )r   encodedigest)r3   r4   counterbyter   r   r   r1   k   s    zPRNG.block_generatorN)__name__
__module____qualname__r5   r=   r1   r   r   r   r   r/   Z   s   r/   c                 C   sX   t | dt| }tt|d|d  d }d|  krD|k sTn J d||f|S )Nr      r   )r/   r*   r   binasciihexlify)r4   r)   r+   numberr   r   r   %randrange_from_seed__overshoot_modulou   s    $rI   c                 C   s   d| > d S r(   r   )Znumbitsr   r   r   lsb_of_ones   s    rJ   c                 C   s2   t t| d dd }|d }|d }|||fS )Nr   r   r   )r   mathlog)r)   bitsr:   	extrabitsr   r   r   bits_and_bytes   s    rO   c                 C   st   t |\}}}|r|d7 }||  d | }d|t|  | }dtt|d }d|  krj|k spn J |S )Nr    rE   )rO   r?   r   r   rF   rG   )r4   r)   hashmodrM   Z_bytesrN   r+   rH   r   r   r   #randrange_from_seed__truncate_bytes   s    rR   c                 C   s   t t|d dd }|d d }||  d | }d|t|  | }d| | }|rtt|d t|@ |dd   }dt t	|d }d|  kr|k sn J |S )Nr   r   r$   r   rP   r   rE   )
r   rK   rL   r?   r   r   r   rJ   rF   rG   )r4   r)   rQ   rM   Zmaxbytesr+   ZtopbitsrH   r   r   r   "randrange_from_seed__truncate_bits   s    $rS   c                 C   s|   |dksJ t |\}}}t| }td}|rFtt|dt|@ }t||| d }d|  krn|k r"n q"|S q"d S )Nr   r   )rO   r/   r   r   r   rJ   string_to_number)r4   r)   rM   r:   rN   generateZ	extrabyteguessr   r   r    randrange_from_seed__trytryagain   s    rW   c                 C   sN   t |}dtd|  d }t||   }t||ksJJ t||f|S Nz%0r   r    )r*   strrF   	unhexlifyr>   r   numr)   lZfmt_strstringr   r   r   number_to_string   s
    r_   c                 C   s:   t |}dtd|  d }t||   }|d | S rX   )r*   rY   rF   rZ   r>   r[   r   r   r   number_to_string_crop   s    r`   c                 C   s   t t| dS NrE   )r   rF   rG   )r^   r   r   r   rT      s    rT   c                 C   s4   t |}t| |ks$J t| |ftt| dS ra   )r*   r   r   rF   rG   )r^   r)   r]   r   r   r   string_to_number_fixedlen   s    rb   c                 C   s   t | |}t ||}||fS r0   )r_   rsr)   r_strs_strr   r   r   sigencode_strings   s    

rh   c                 C   s   t | ||\}}|| S )a  
    Encode the signature to raw format (:term:`raw encoding`)

    It's expected that this function will be used as a `sigencode=` parameter
    in :func:`ecdsa.keys.SigningKey.sign` method.

    :param int r: first parameter of the signature
    :param int s: second parameter of the signature
    :param int order: the order of the curve over which the signature was
        computed

    :return: raw encoding of ECDSA signature
    :rtype: bytes
    rh   rc   r   r   r   sigencode_string   s    rj   c                 C   s   t t | t |S )a  
    Encode the signature into the ECDSA-Sig-Value structure using :term:`DER`.

    Encodes the signature to the following :term:`ASN.1` structure::

        Ecdsa-Sig-Value ::= SEQUENCE {
            r       INTEGER,
            s       INTEGER
        }

    It's expected that this function will be used as a `sigencode=` parameter
    in :func:`ecdsa.keys.SigningKey.sign` method.

    :param int r: first parameter of the signature
    :param int s: second parameter of the signature
    :param int order: the order of the curve over which the signature was
        computed

    :return: DER encoding of ECDSA signature
    :rtype: bytes
    )r	   Zencode_sequenceZencode_integerrd   re   r)   r   r   r   sigencode_der  s    rl   c                 C   s    ||d kr|| }t | ||S r%   ri   rk   r   r   r   sigencode_strings_canonize  s    rm   c                 C   s    ||d kr|| }t | ||S r%   )rj   rk   r   r   r   sigencode_string_canonize%  s    rn   c                 C   s    ||d kr|| }t | ||S r%   )rl   rk   r   r   r   sigencode_der_canonize+  s    ro   c                   @   s   e Zd ZdZdS )MalformedSignatureaB  
    Raised by decoding functions when the signature is malformed.

    Malformed in this context means that the relevant strings or integers
    do not match what a signature over provided curve would create. Either
    because the byte strings have incorrect lengths or because the encoded
    values are too large.
    N)rB   rC   rD   __doc__r   r   r   r   rp   1  s   	rp   c                 C   sd   t | } t|}t| d| ks8tdd| t| t| d| |}t| |d |}||fS )a  
    Decoder for :term:`raw encoding`  of ECDSA signatures.

    raw encoding is a simple concatenation of the two integers that comprise
    the signature, with each encoded using the same amount of bytes depending
    on curve size/order.

    It's expected that this function will be used as the `sigdecode=`
    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.

    :param signature: encoded signature
    :type signature: bytes like object
    :param order: order of the curve over which the signature was computed
    :type order: int

    :raises MalformedSignature: when the encoding of the signature is invalid

    :return: tuple with decoded 'r' and 's' values of signature
    :rtype: tuple of ints
    r   zWInvalid length of signature, expected {0} bytes long, provided string is {1} bytes longN)r
   r*   r   rp   formatrb   )	signaturer)   r]   rd   re   r   r   r   sigdecode_string>  s    rt   c                 C   s   t | dkstdt | | \}}t|}t|}t|}t ||ks^td|t |t ||ks~td|t |t||}t||}||fS )a  
    Decode the signature from two strings.

    First string needs to be a big endian encoding of 'r', second needs to
    be a big endian encoding of the 's' parameter of an ECDSA signature.

    It's expected that this function will be used as the `sigdecode=`
    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.

    :param list rs_strings: list of two bytes-like objects, each encoding one
        parameter of signature
    :param int order: order of the curve over which the signature was computed

    :raises MalformedSignature: when the encoding of the signature is invalid

    :return: tuple with decoded 'r' and 's' values of signature
    :rtype: tuple of ints
    r   z3Invalid number of strings provided: {0}, expected 2zjInvalid length of first string ('r' parameter), expected {0} bytes long, provided string is {1} bytes longzkInvalid length of second string ('s' parameter), expected {0} bytes long, provided string is {1} bytes long)r   rp   rr   r
   r*   rb   )
rs_stringsr)   rf   rg   r]   rd   re   r   r   r   sigdecode_strings_  s2    

rv   c                 C   sr   t | } t| \}}|dkr2tdt| t|\}}t|\}}|dkrjtdt| ||fS )a  
    Decoder for DER format of ECDSA signatures.

    DER format of signature is one that uses the :term:`ASN.1` :term:`DER`
    rules to encode it as a sequence of two integers::

        Ecdsa-Sig-Value ::= SEQUENCE {
            r       INTEGER,
            s       INTEGER
        }

    It's expected that this function will be used as as the `sigdecode=`
    parameter to the :func:`ecdsa.keys.VerifyingKey.verify` method.

    :param sig_der: encoded signature
    :type sig_der: bytes like object
    :param order: order of the curve over which the signature was computed
    :type order: int

    :raises UnexpectedDER: when the encoding of signature is invalid

    :return: tuple with decoded 'r' and 's' values of signature
    :rtype: tuple of ints
    r"   ztrailing junk after DER sig: %sz#trailing junk after DER numbers: %s)r
   r	   Zremove_sequenceZUnexpectedDERrF   rG   Zremove_integer)Zsig_derr)   ru   emptyrd   restre   r   r   r   sigdecode_der  s    ry   )N)1
__future__r   r,   rK   rF   syshashlibr   sixr   r   r   r   r   r	   Z_compatr
   Zoid_ecPublicKeyZ
encode_oidZencoded_oid_ecPublicKeyZoid_ecDHZ	oid_ecMQVversion_infor   r'   r*   r.   r/   rI   rJ   rO   rR   rS   rW   r_   r`   rT   rb   rh   rj   rl   rm   rn   ro   	Exceptionrp   rt   rv   ry   r   r   r   r   <module>   sR   





!.