o
    Tiht                     @  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mZ d dl	m
Z
mZmZmZmZmZmZ ddlmZ ddlmZmZ ddlmZmZmZmZmZmZmZmZmZ ej d	kr`d d
l	m!Z! nd d
l"m!Z! zjd dl#m$Z$ d dl%m&Z& d dl'm(Z( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z; d dl<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZGmHZHmIZImJZJmKZKmLZL dZMW n eNy   dZMY nw e
re=e?B ZOe2e4B ZPe:e;B e7B e8B ZQeOePB eQB ZRe=e2B e:B e7B ZSe?e4B e;B e8B ZTh dZUd)ddZVG dd deZWG dd deWZXG dd  d eWZYeMrKG d!d" d"eWZZG d#d$ d$eWZ[G d%d& d&eZZ\G d'd( d(eWZ]dS dS )*    )annotationsN)ABCabstractmethod)TYPE_CHECKINGAnyClassVarNoReturnUnioncastoverload   InvalidKeyError)HashlibHashJWKDict)	base64url_decodebase64url_encodeder_to_raw_signatureforce_bytesfrom_base64url_uintis_pem_format
is_ssh_keyraw_to_der_signatureto_base64url_uint)      )Literal)InvalidSignature)default_backend)hashes)padding)
ECDSA	SECP256K1	SECP256R1	SECP384R1	SECP521R1EllipticCurveEllipticCurvePrivateKeyEllipticCurvePrivateNumbersEllipticCurvePublicKeyEllipticCurvePublicNumbers)Ed448PrivateKeyEd448PublicKey)Ed25519PrivateKeyEd25519PublicKey)RSAPrivateKeyRSAPrivateNumbersRSAPublicKeyRSAPublicNumbersrsa_crt_dmp1rsa_crt_dmq1rsa_crt_iqmprsa_recover_prime_factors)EncodingNoEncryptionPrivateFormatPublicFormatload_pem_private_keyload_pem_public_keyload_ssh_public_keyTF>   EdDSAPS256RS512RS256RS384PS384PS512ES256ES512ES384ES256KES521returndict[str, Algorithm]c                  C  s   t  ttjttjttjd} trG| ttjttjttjttjttjttjttjttjt	t	jt	t	jt	t	jt
 d | S )zE
    Returns the algorithms that are implemented by the library.
    )noneZHS256ZHS384ZHS512)rA   rB   r@   rE   rH   rG   rI   rF   r?   rC   rD   r>   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmRSAPSSAlgorithmOKPAlgorithm)Zdefault_algorithms rX   N/var/www/html/evchargy.com/venv/lib/python3.10/site-packages/jwt/algorithms.pyget_default_algorithmsp   s0   rZ   c                   @  s   e Zd ZdZd"ddZed#d	d
Zed$ddZed%ddZe	e
ed&ddZe	e
ed'd(ddZe
ed'd)ddZe
ed*dd Zd!S )+	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    bytestrbytesrJ   c                 C  sj   t | dd}|du rttr-t|tr-t|tjr-tj| t	 d}|
| t| S t|| S )z
        Compute a hash digest using the specified algorithm's hash algorithm.

        If there is no hash algorithm, raises a NotImplementedError.
        hash_algN)backend)getattrNotImplementedErrorrR   
isinstancetype
issubclassr   ZHashAlgorithmZHashr   rS   r]   finalizedigest)selfr\   r^   rf   rX   rX   rY   compute_hash_digest   s   

zAlgorithm.compute_hash_digestkeyr   c                 C     dS )z
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        NrX   rg   ri   rX   rX   rY   prepare_key       zAlgorithm.prepare_keymsgc                 C  rj   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        NrX   rg   rn   ri   rX   rX   rY   sign   rm   zAlgorithm.signsigboolc                 C  rj   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        NrX   rg   rn   ri   rq   rX   rX   rY   verify   rm   zAlgorithm.verifyas_dictLiteral[True]r   c                 C     d S NrX   key_objru   rX   rX   rY   to_jwk      zAlgorithm.to_jwkFLiteral[False]strc                 C  rw   rx   rX   ry   rX   rX   rY   r{      r|   Union[JWKDict, str]c                 C  rj   )z3
        Serializes a given key into a JWK
        NrX   ry   rX   rX   rY   r{      rm   jwkstr | JWKDictc                 C  rj   )zJ
        Deserializes a given key from JWK back into a key object
        NrX   r   rX   rX   rY   from_jwk   rm   zAlgorithm.from_jwkN)r\   r]   rJ   r]   )ri   r   rJ   r   )rn   r]   ri   r   rJ   r]   )rn   r]   ri   r   rq   r]   rJ   rr   )ru   rv   rJ   r   F)ru   r}   rJ   r~   )ru   rr   rJ   r   )r   r   rJ   r   )__name__
__module____qualname____doc__rh   r   rl   rp   rt   r   staticmethodr{   r   rX   rX   rX   rY   r[      s.    
r[   c                   @  sL   e Zd ZdZdddZdd
dZdddZedd ddZed!ddZ	dS )"rM   zZ
    Placeholder for use when no signing or verification
    operations are required.
    ri   
str | NonerJ   Nonec                 C  s    |dkrd }|d urt d|S )N z*When alg = "none", key value must be None.r   rk   rX   rX   rY   rl      s
   zNoneAlgorithm.prepare_keyrn   r]   c                 C  rj   )N    rX   ro   rX   rX   rY   rp         zNoneAlgorithm.signrq   rr   c                 C  rj   )NFrX   rs   rX   rX   rY   rt      r   zNoneAlgorithm.verifyFrz   r   ru   r   c                 C     t  rx   ra   ry   rX   rX   rY   r{         zNoneAlgorithm.to_jwkr   r   c                 C  r   rx   r   r   rX   rX   rY   r      r   zNoneAlgorithm.from_jwkN)ri   r   rJ   r   )rn   r]   ri   r   rJ   r]   )rn   r]   ri   r   rq   r]   rJ   rr   r   )rz   r   ru   rr   rJ   r   )r   r   rJ   r   )
r   r   r   r   rl   rp   rt   r   r{   r   rX   rX   rX   rY   rM      s    

	
rM   c                   @  s   e Zd ZU dZejZded< ejZ	ded< ej
Zded< d)d
dZd*ddZeed+ddZeed,d-ddZed,d.ddZed/d d!Zd0d#d$Zd1d&d'Zd(S )2rN   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rO   rP   rQ   r^   r   rJ   r   c                 C  
   || _ d S rx   r^   rg   r^   rX   rX   rY   __init__     
zHMACAlgorithm.__init__ri   str | bytesr]   c                 C  s$   t |}t|st|rtd|S )NzdThe specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.)r   r   r   r   rg   ri   	key_bytesrX   rX   rY   rl     s   zHMACAlgorithm.prepare_keyrz   ru   rv   r   c                 C  rw   rx   rX   ry   rX   rX   rY   r{        zHMACAlgorithm.to_jwkFr}   r~   c                 C  rw   rx   rX   ry   rX   rX   rY   r{     r   rr   r   c                 C  s(   t t|  dd}|r|S t|S )Noct)kkty)r   r   decodejsondumps)rz   ru   r   rX   rX   rY   r{     s   
r   r   c                 C  sh   zt | trt| }n
t | tr| }ntW n ty"   tdw |ddkr.tdt|d S )NKey is not valid JSONr   r   zNot an HMAC keyr   )	rb   r~   r   loadsdict
ValueErrorr   getr   )r   objrX   rX   rY   r   )  s   

zHMACAlgorithm.from_jwkrn   c                 C  s   t ||| j S rx   )hmacnewr^   rf   ro   rX   rX   rY   rp   :     zHMACAlgorithm.signrq   c                 C  s   t || ||S rx   )r   compare_digestrp   rs   rX   rX   rY   rt   =  r   zHMACAlgorithm.verifyN)r^   r   rJ   r   )ri   r   rJ   r]   )rz   r   ru   rv   rJ   r   r   )rz   r   ru   r}   rJ   r~   )rz   r   ru   rr   rJ   r   )r   r   rJ   r]   )rn   r]   ri   r]   rJ   r]   )rn   r]   ri   r]   rq   r]   rJ   rr   )r   r   r   r   hashlibsha256rO   __annotations__sha384rP   sha512rQ   r   rl   r   r   r{   r   rp   rt   rX   rX   rX   rY   rN      s&   
 


rN   c                   @  s   e Zd ZU dZejZded< ejZded< ejZded< d,d
dZ	d-ddZ
eed.ddZeed/d0ddZe	d/d1ddZed2d d!Zd3d%d&Zd4d)d*Zd+S )5rT   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]rO   rP   rQ   r^   type[hashes.HashAlgorithm]rJ   r   c                 C  r   rx   r   r   rX   rX   rY   r   M  r   zRSAAlgorithm.__init__ri   AllowedRSAKeys | str | bytesAllowedRSAKeysc                 C  s   t |ttfr	|S t |ttfstdt|}z|dr&ttt	|W S ttt
|d dW S  ty?   ttt| Y S w )NExpecting a PEM-formatted key.s   ssh-rsapassword)rb   r/   r1   r]   r~   	TypeErrorr   
startswithr
   r=   r;   r   r<   r   rX   rX   rY   rl   P  s   
zRSAAlgorithm.prepare_keyrz   ru   rv   r   c                 C  rw   rx   rX   ry   rX   rX   rY   r{   c  r   zRSAAlgorithm.to_jwkFr}   r~   c                 C  rw   rx   rX   ry   rX   rX   rY   r{   h  r   rr   r   c                 C  s   d }t | drD|  }ddgt|jj t|jj t|j t|j t|j	 t|j
 t|j t|j d
}n t | dr`|  }ddgt|j t|j d}ntd|rh|S t|S )Nprivate_numbersRSArp   )
r   key_opsnedpqdpdqqirt   )r   r   r   r   Not a public or private key)hasattrr   r   public_numbersr   r   r   r   r   r   dmp1dmq1iqmpr   r   r   )rz   ru   r   numbersrX   rX   rY   r{   m  s2   


r   r   c           	   	     s  zt | trt|  n
t | tr|  ntW n ty"   tdw  ddkr.tdd v rd v rd v rd v rBtd	g d
} fdd|D }t|}|r]t	|s]tdt
t d t d }|rtt d t d t d t d t d t d |d}| S t d }t|j||j\}}t|||t||t||t|||d}| S d v rd v rt
t d t d  S td)Nr   r   r   zNot an RSA keyr   r   r   Zothz5Unsupported RSA private key: > 2 primes not supported)r   r   r   r   r   c                   s   g | ]}| v qS rX   rX   ).0propr   rX   rY   
<listcomp>  s    z)RSAAlgorithm.from_jwk.<locals>.<listcomp>z@RSA key must include all parameters if any are present besides dr   r   r   r   r   )r   r   r   r   r   r   r   r   )rb   r~   r   r   r   r   r   r   anyallr2   r   r0   r6   r   r   r3   r4   r5   private_key
public_key)	r   Zother_propsZprops_foundZany_props_foundr   r   r   r   r   rX   r   rY   r     sz   













zRSAAlgorithm.from_jwkrn   r]   r/   c                 C  s   | |t |  S rx   )rp   r    PKCS1v15r^   ro   rX   rX   rY   rp     s   zRSAAlgorithm.signr1   rq   c                 C  s4   z| ||t |   W dS  ty   Y dS w )NTF)rt   r    r   r^   r   rs   rX   rX   rY   rt     s   zRSAAlgorithm.verifyNr^   r   rJ   r   )ri   r   rJ   r   )rz   r   ru   rv   rJ   r   r   )rz   r   ru   r}   rJ   r~   )rz   r   ru   rr   rJ   r   )r   r   rJ   r   rn   r]   ri   r/   rJ   r]   rn   r]   ri   r1   rq   r]   rJ   rr   )r   r   r   r   r   rO   r   rP   rQ   r   rl   r   r   r{   r   rp   rt   rX   rX   rX   rY   rT   C  s(   
 

(
GrT   c                   @  s   e Zd ZU dZejZded< ejZded< ejZded< d,d
dZ	d-ddZ
d.ddZd/ddZeed0dd Zeed1d2d$d Ze	!d1d3d&d Zed4d)d*Zd+S )5rU   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   rO   rP   rQ   r^   r   rJ   r   c                 C  r   rx   r   r   rX   rX   rY   r     r   zECAlgorithm.__init__ri   AllowedECKeys | str | bytesAllowedECKeysc                 C  s   t |ttfr	|S t |ttfstdt|}z|dr#t|}nt	|}W n t
y7   t|d d}Y nw t |ttfsCtd|S )Nr   s   ecdsa-sha2-r   zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)rb   r'   r)   r]   r~   r   r   r   r=   r<   r   r;   r   )rg   ri   r   Z
crypto_keyrX   rX   rY   rl     s(   

zECAlgorithm.prepare_keyrn   r]   r'   c                 C  s    | |t|  }t||jS rx   )rp   r!   r^   r   curve)rg   rn   ri   der_sigrX   rX   rY   rp     s   zECAlgorithm.sign'AllowedECKeys'rq   rr   c                 C  sn   zt ||j}W n
 ty   Y dS w zt|tr| n|}|||t|   W dS  t	y6   Y dS w )NFT)
r   r   r   rb   r'   r   rt   r!   r^   r   )rg   rn   ri   rq   r   r   rX   rX   rY   rt     s   
zECAlgorithm.verifyrz   ru   rv   r   c                 C  rw   rx   rX   ry   rX   rX   rY   r{   )  r   zECAlgorithm.to_jwkFr}   r~   c                 C  rw   rx   rX   ry   rX   rX   rY   r{   .  r   r   c                 C  s   t | tr|   }nt | tr|  }ntdt | jtr#d}n#t | jtr,d}nt | jt	r5d}nt | jt
r>d}ntd| j d|t|j t|j d}t | trgt|  j |d	< |rk|S t|S )
Nr   P-256P-384P-521	secp256k1Invalid curve: EC)r   crvxyr   )rb   r'   r   r   r)   r   r   r#   r$   r%   r"   r   r   r   r   r   Zprivate_valuer   r   )rz   ru   r   r   r   rX   rX   rY   r{   3  s8   




r   r   c                 C  s  zt | trt| }n
t | tr| }ntW n ty"   tdw |ddkr.tdd|vs6d|vr:tdt|d}t|d}|d}|dkrlt	|t	|  kr_d	krhn td
t
 }nhtd
|dkrt	|t	|  kr~dkrn tdt }nItd|dkrt	|t	|  krdkrn tdt }n*td|dkrt	|t	|  krd	krn tdt }ntdtd| ttj|ddtj|dd|d}d|vr| S t|d}t	|t	|krtdt	||ttj|dd| S )Nr   r   r   zNot an Elliptic curve keyr   r   r   r       z)Coords should be 32 bytes for curve P-256r   0   z)Coords should be 48 bytes for curve P-384r   B   z)Coords should be 66 bytes for curve P-521r   z-Coords should be 32 bytes for curve secp256k1r   big)	byteorder)r   r   r   r   z!D should be {} bytes for curve {})rb   r~   r   r   r   r   r   r   r   lenr#   r$   r%   r"   r*   int
from_bytesr   r(   r   )r   r   r   r   r   Z	curve_objr   r   rX   rX   rY   r   Z  sv   



zECAlgorithm.from_jwkNr   )ri   r   rJ   r   )rn   r]   ri   r'   rJ   r]   )rn   r]   ri   r   rq   r]   rJ   rr   )rz   r   ru   rv   rJ   r   r   )rz   r   ru   r}   rJ   r~   )rz   r   ru   rr   rJ   r   )r   r   rJ   r   )r   r   r   r   r   rO   r   rP   rQ   r   rl   rp   rt   r   r   r{   r   rX   rX   rX   rY   rU     s(   
 



&rU   c                   @  s$   e Zd ZdZdddZdddZdS )rV   zA
        Performs a signature using RSASSA-PSS with MGF1
        rn   r]   ri   r/   rJ   c                 C  s,   | |tjt|  |  jd|  S )NZmgfZsalt_length)rp   r    PSSMGF1r^   digest_sizero   rX   rX   rY   rp     s   zRSAPSSAlgorithm.signr1   rq   rr   c              	   C  sJ   z| ||tjt|  |  jd|   W dS  ty$   Y dS w )Nr   TF)rt   r    r   r   r^   r   r   rs   rX   rX   rY   rt     s   	zRSAPSSAlgorithm.verifyNr   r   )r   r   r   r   rp   rt   rX   rX   rX   rY   rV     s    

rV   c                   @  s|   e Zd ZdZd'ddZd(ddZd)ddZd*ddZee	d+ddZ
ee	d,d-ddZ
e	d,d.d!dZ
e	d/d$d%Zd&S )0rW   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        kwargsr   rJ   r   c                 K  rw   rx   rX   )rg   r   rX   rX   rY   r     r   zOKPAlgorithm.__init__ri   AllowedOKPKeys | str | bytesAllowedOKPKeysc                 C  s   t |ttfr?t |tr|dn|}t |tr|dn|}d|v r(t|}nd|v r3t|d d}n|dd dkr?t|}t |tt	t
tfsLtd|S )	Nutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr   r      zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)rb   r]   r~   r   encoder<   r;   r=   r-   r.   r+   r,   r   )rg   ri   Zkey_strr   rX   rX   rY   rl     s"   

zOKPAlgorithm.prepare_keyrn   r   #Ed25519PrivateKey | Ed448PrivateKeyr]   c                 C  s"   t |tr
|dn|}||S )aS  
            Sign a message ``msg`` using the EdDSA private key ``key``
            :param str|bytes msg: Message to sign
            :param Ed25519PrivateKey}Ed448PrivateKey key: A :class:`.Ed25519PrivateKey`
                or :class:`.Ed448PrivateKey` isinstance
            :return bytes signature: The signature, as bytes
            r   )rb   r~   r   rp   )rg   rn   ri   	msg_bytesrX   rX   rY   rp     s   

zOKPAlgorithm.signrq   rr   c                 C  sr   z.t |tr|dn|}t |tr|dn|}t |ttfr$| n|}||| W dS  ty8   Y dS w )a  
            Verify a given ``msg`` against a signature ``sig`` using the EdDSA key ``key``

            :param str|bytes sig: EdDSA signature to check ``msg`` against
            :param str|bytes msg: Message to sign
            :param Ed25519PrivateKey|Ed25519PublicKey|Ed448PrivateKey|Ed448PublicKey key:
                A private or public EdDSA key instance
            :return bool verified: True if signature is valid, False if not.
            r   TF)rb   r~   r   r-   r+   r   rt   r   )rg   rn   ri   rq   r   Z	sig_bytesr   rX   rX   rY   rt     s   
zOKPAlgorithm.verifyru   rv   r   c                 C  rw   rx   rX   ri   ru   rX   rX   rY   r{     r   zOKPAlgorithm.to_jwkFr}   r~   c                 C  rw   rx   rX   r   rX   rX   rY   r{   	  r   r   c                 C  s   t | ttfr.| jtjtjd}t | trdnd}tt|	 d|d}|r)|S t
|S t | ttfrp| jtjtjt d}|  jtjtjd}t | trRdnd}tt|	 tt|	 d|d}|rk|S t
|S td)	N)encodingformatEd25519Ed448OKP)r   r   r   )r   r   Zencryption_algorithm)r   r   r   r   r   )rb   r.   r,   public_bytesr7   ZRawr:   r   r   r   r   r   r-   r+   Zprivate_bytesr9   r8   r   r   )ri   ru   r   r   r   r   rX   rX   rY   r{     sB   

r   r   c              
   C  s  zt | trt| }n
t | tr| }ntW n ty"   tdw |ddkr.td|d}|dkrB|dkrBtd| d	|vrJtd
t|d	}z+d|vrf|dkr`t	
|W S t
|W S t|d}|dkrwt|W S t|W S  ty } ztd|d }~ww )Nr   r   r   zNot an Octet Key Pairr   r   r   r   r   zOKP should have "x" parameterr   zInvalid key parameter)rb   r~   r   r   r   r   r   r   r   r.   Zfrom_public_bytesr,   r-   Zfrom_private_bytesr+   )r   r   r   r   r   errrX   rX   rY   r   =  s>   



zOKPAlgorithm.from_jwkN)r   r   rJ   r   )ri   r   rJ   r   )rn   r   ri   r   rJ   r]   )rn   r   ri   r   rq   r   rJ   rr   )ri   r   ru   rv   rJ   r   r   )ri   r   ru   r}   rJ   r~   )ri   r   ru   rr   rJ   r   )r   r   rJ   r   )r   r   r   r   r   rl   rp   rt   r   r   r{   r   rX   rX   rX   rY   rW     s     



.rW   )rJ   rK   )^
__future__r   r   r   r   sysabcr   r   typingr   r   r   r   r	   r
   r   
exceptionsr   typesr   r   utilsr   r   r   r   r   r   r   r   r   version_infor   Ztyping_extensionsZcryptography.exceptionsr   Zcryptography.hazmat.backendsr   Zcryptography.hazmat.primitivesr   Z)cryptography.hazmat.primitives.asymmetricr    Z,cryptography.hazmat.primitives.asymmetric.ecr!   r"   r#   r$   r%   r&   r'   r(   r)   r*   Z/cryptography.hazmat.primitives.asymmetric.ed448r+   r,   Z1cryptography.hazmat.primitives.asymmetric.ed25519r-   r.   Z-cryptography.hazmat.primitives.asymmetric.rsar/   r0   r1   r2   r3   r4   r5   r6   Z,cryptography.hazmat.primitives.serializationr7   r8   r9   r:   r;   r<   r=   rR   ModuleNotFoundErrorr   r   r   ZAllowedKeysZAllowedPrivateKeysZAllowedPublicKeysZrequires_cryptographyrZ   r[   rM   rN   rT   rU   rV   rW   rX   rX   rX   rY   <module>   sh    $,
0($


"KF & 7  