o
    6d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rIdd Zndd Zejdk rWd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   aC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\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>.   s   ( 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_length3      r&   c                 C   s   |   pdS Nr   )r&   r%   r   r   r   r&   8      c                 C   s   dt d|   d S )Nr   z%xr   )r   )orderr   r   r   orderlen<   s   r+   c                 C   sv   | dksJ |du rt j}t| d }|d d }	 ||}t|}t|d| ddd }d|  k r9| k r:|S  q)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   T)baser   )osurandomr&   r   r   )r*   ZentropyZupper_2Z	upper_256r   Zent_2Zrand_numr   r   r   	randrange@   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__^   r'   zPRNG.__init__c                    s,    fddt |D }trd|S t|S )Nc                    s   g | ]}t  jqS r   )r   r3   )r   ir4   r   r   
<listcomp>b   s    z!PRNG.__call__.<locals>.<listcomp>r   )ranger   r"   bytes)r4   numbytesar   r8   r   __call__a   s   
zPRNG.__call__c                 c   s6    d}	 t d||f   D ]}|V  q|d7 }q)Nr   Tz
prng-%d-%sr   )r   encodedigest)r4   r5   counterbyter   r   r   r2   i   s   zPRNG.block_generatorN)__name__
__module____qualname__r6   r>   r2   r   r   r   r   r0   X   s    r0   c                 C   sX   t | dt| }tt|d|d  d }d|  kr"|k s*n J d||f|S )Nr      r   )r0   r+   r   binasciihexlify)r5   r*   r,   numberr   r   r   %randrange_from_seed__overshoot_modulos   s   $rJ   c                 C   s   d| > d S r(   r   )Znumbitsr   r   r   lsb_of_ones   r)   rK   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   
rP   c                 C   sv   t |\}}}|r|d7 }||  d | }d|t|  | }dtt|d }d|  kr6|k s9J  J |S )Nr    rF   )rP   r@   r   r   rG   rH   )r5   r*   hashmodrN   Z_bytesrO   r,   rI   r   r   r   #randrange_from_seed__truncate_bytes   s   rS   c                 C   s   t t|d dd }|d d }||  d | }d|t|  | }d| | }|r@tt|d t|@ |dd   }dt t	|d }d|  krU|k sXJ  J |S )Nr   r   r#   r   rQ   r   rF   )
r   rL   rM   r@   r   r   r   rK   rG   rH   )r5   r*   rR   rN   Zmaxbytesr,   ZtopbitsrI   r   r   r   "randrange_from_seed__truncate_bits   s   $rT   c                 C   sv   |dksJ t |\}}}t| }	 td}|r$tt|dt|@ }t||| d }d|  kr9|k r:|S  q)Nr   Tr   )rP   r0   r   r   r   rK   string_to_number)r5   r*   rN   r;   rO   generateZ	extrabyteguessr   r   r    randrange_from_seed__trytryagain   s   rX   c                 C   sN   t |}dtd|  d }t||   }t||ks%J t||f|S Nz%0r   r    )r+   strrG   	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 rY   )r+   rZ   rG   r[   r?   r\   r   r   r   number_to_string_crop   s   ra   c                 C   s   t t| dS NrF   )r   rG   rH   )r_   r   r   r   rU      r'   rU   c                 C   s4   t |}t| |ksJ t| |ftt| dS rb   )r+   r   r   rG   rH   )r_   r*   r^   r   r   r   string_to_number_fixedlen   s   rc   c                 C   s   t | |}t ||}||fS r1   )r`   rsr*   r_strs_strr   r   r   sigencode_strings   s   

ri   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
    ri   rd   r   r   r   sigencode_string   s   rk   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re   rf   r*   r   r   r   sigencode_der   s   rm   c                 C       ||d kr
|| }t | ||S r$   rj   rl   r   r   r   sigencode_strings_canonize     ro   c                 C   rn   r$   )rk   rl   r   r   r   sigencode_string_canonize#  rp   rq   c                 C   rn   r$   )rm   rl   r   r   r   sigencode_der_canonize)  rp   rr   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)rC   rD   rE   __doc__r   r   r   r   rs   /  s    	rs   c                 C   sd   t | } t|}t| d| kst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   rs   formatrc   )	signaturer*   r^   re   rf   r   r   r   sigdecode_string<  s   rw   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   rs   ru   r
   r+   rc   )
rs_stringsr*   rg   rh   r^   re   rf   r   r   r   sigdecode_strings]  s.   

ry   c                 C   sr   t | } t| \}}|dkrtdt| t|\}}t|\}}|dkr5t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
        ztrailing junk after DER sig: %sz#trailing junk after DER numbers: %s)r
   r	   Zremove_sequenceZUnexpectedDERrG   rH   Zremove_integer)Zsig_derr*   rx   emptyre   restrf   r   r   r   sigdecode_der  s   r}   r1   )1
__future__r   r-   rL   rG   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/   r0   rJ   rK   rP   rS   rT   rX   r`   ra   rU   rc   ri   rk   rm   ro   rq   rr   	Exceptionrs   rw   ry   r}   r   r   r   r   <module>   sT    





!.