o
    ifht                     @  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>   ES256ES384ES512ES521EdDSAPS256PS384PS512RS256RS384RS512ES256K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.
    )noneHS256HS384HS512)rF   rG   rH   r>   rI   r?   rA   r@   rC   rD   rE   rB   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmRSAPSSAlgorithmOKPAlgorithm)default_algorithms r\   G/var/www/html/corbot_env/lib/python3.10/site-packages/jwt/algorithms.pyget_default_algorithmsp   s0   r^   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NotImplementedErrorrU   
isinstancetype
issubclassr   HashAlgorithmHashr   rV   ra   finalizedigest)selfr`   rb   rl   r\   r\   r]   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().
        Nr\   rm   ro   r\   r\   r]   prepare_key       zAlgorithm.prepare_keymsgc                 C  rp   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nr\   rm   rt   ro   r\   r\   r]   sign   rs   zAlgorithm.signsigboolc                 C  rp   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nr\   rm   rt   ro   rw   r\   r\   r]   verify   rs   zAlgorithm.verifyas_dictLiteral[True]r   c                 C     d S Nr\   key_objr{   r\   r\   r]   to_jwk      zAlgorithm.to_jwkFLiteral[False]strc                 C  r}   r~   r\   r   r\   r\   r]   r      r   Union[JWKDict, str]c                 C  rp   )z3
        Serializes a given key into a JWK
        Nr\   r   r\   r\   r]   r      rs   jwkstr | JWKDictc                 C  rp   )zJ
        Deserializes a given key from JWK back into a key object
        Nr\   r   r\   r\   r]   from_jwk   rs   zAlgorithm.from_jwkN)r`   ra   rJ   ra   )ro   r   rJ   r   )rt   ra   ro   r   rJ   ra   )rt   ra   ro   r   rw   ra   rJ   rx   )r{   r|   rJ   r   F)r{   r   rJ   r   )r{   rx   rJ   r   )r   r   rJ   r   )__name__
__module____qualname____doc__rn   r   rr   rv   rz   r   staticmethodr   r   r\   r\   r\   r]   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 )"rP   zZ
    Placeholder for use when no signing or verification
    operations are required.
    ro   
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   rq   r\   r\   r]   rr      s
   zNoneAlgorithm.prepare_keyrt   ra   c                 C  rp   )N    r\   ru   r\   r\   r]   rv         zNoneAlgorithm.signrw   rx   c                 C  rp   )NFr\   ry   r\   r\   r]   rz      r   zNoneAlgorithm.verifyFr   r   r{   r   c                 C     t  r~   re   r   r\   r\   r]   r         zNoneAlgorithm.to_jwkr   r   c                 C  r   r~   r   r   r\   r\   r]   r      r   zNoneAlgorithm.from_jwkN)ro   r   rJ   r   )rt   ra   ro   r   rJ   ra   )rt   ra   ro   r   rw   ra   rJ   rx   r   )r   r   r{   rx   rJ   r   )r   r   rJ   r   )
r   r   r   r   rr   rv   rz   r   r   r   r\   r\   r\   r]   rP      s    

	
rP   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 )2rQ   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rR   rS   rT   rb   r   rJ   r   c                 C  
   || _ d S r~   rb   rm   rb   r\   r\   r]   __init__     
zHMACAlgorithm.__init__ro   str | bytesra   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   rm   ro   	key_bytesr\   r\   r]   rr     s   zHMACAlgorithm.prepare_keyr   r{   r|   r   c                 C  r}   r~   r\   r   r\   r\   r]   r        zHMACAlgorithm.to_jwkFr   r   c                 C  r}   r~   r\   r   r\   r\   r]   r     r   rx   r   c                 C  s(   t t|  dd}|r|S t|S )Noct)kkty)r   r   decodejsondumps)r   r{   r   r\   r\   r]   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   )	rf   r   r   loadsdict
ValueErrorr   getr   )r   objr\   r\   r]   r   )  s   

zHMACAlgorithm.from_jwkrt   c                 C  s   t ||| j S r~   )hmacnewrb   rl   ru   r\   r\   r]   rv   :     zHMACAlgorithm.signrw   c                 C  s   t || ||S r~   )r   compare_digestrv   ry   r\   r\   r]   rz   =  r   zHMACAlgorithm.verifyN)rb   r   rJ   r   )ro   r   rJ   ra   )r   r   r{   r|   rJ   r   r   )r   r   r{   r   rJ   r   )r   r   r{   rx   rJ   r   )r   r   rJ   ra   )rt   ra   ro   ra   rJ   ra   )rt   ra   ro   ra   rw   ra   rJ   rx   )r   r   r   r   hashlibsha256rR   __annotations__sha384rS   sha512rT   r   rr   r   r   r   r   rv   rz   r\   r\   r\   r]   rQ      s&   
 


rQ   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 )5rW   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]rR   rS   rT   rb   type[hashes.HashAlgorithm]rJ   r   c                 C  r   r~   r   r   r\   r\   r]   r   M  r   zRSAAlgorithm.__init__ro   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)rf   r/   r1   ra   r   	TypeErrorr   
startswithr
   r=   r;   r   r<   r   r\   r\   r]   rr   P  s   
zRSAAlgorithm.prepare_keyr   r{   r|   r   c                 C  r}   r~   r\   r   r\   r\   r]   r   c  r   zRSAAlgorithm.to_jwkFr   r   c                 C  r}   r~   r\   r   r\   r\   r]   r   h  r   rx   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RSArv   )
r   key_opsnedpqdpdqqirz   )r   r   r   r   Not a public or private key)hasattrr   r   public_numbersr   r   r   r   r   r   dmp1dmq1iqmpr   r   r   )r   r{   r   numbersr\   r\   r]   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   othz5Unsupported RSA private key: > 2 primes not supported)r   r   r   r   r   c                   s   g | ]}| v qS r\   r\   ).0propr   r\   r]   
<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   )rf   r   r   r   r   r   r   r   anyallr2   r   r0   r6   r   r   r3   r4   r5   private_key
public_key)	r   other_propsprops_foundany_props_foundr   r   r   r   r   r\   r   r]   r     sz   













zRSAAlgorithm.from_jwkrt   ra   r/   c                 C  s   | |t |  S r~   )rv   r    PKCS1v15rb   ru   r\   r\   r]   rv     s   zRSAAlgorithm.signr1   rw   c                 C  s4   z| ||t |   W dS  ty   Y dS w )NTF)rz   r    r   rb   r   ry   r\   r\   r]   rz     s   zRSAAlgorithm.verifyNrb   r   rJ   r   )ro   r   rJ   r   )r   r   r{   r|   rJ   r   r   )r   r   r{   r   rJ   r   )r   r   r{   rx   rJ   r   )r   r   rJ   r   rt   ra   ro   r/   rJ   ra   rt   ra   ro   r1   rw   ra   rJ   rx   )r   r   r   r   r   rR   r   rS   rT   r   rr   r   r   r   r   rv   rz   r\   r\   r\   r]   rW   C  s(   
 

(
GrW   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 )5rX   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   rR   rS   rT   rb   r   rJ   r   c                 C  r   r~   r   r   r\   r\   r]   r     r   zECAlgorithm.__init__ro   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)rf   r'   r)   ra   r   r   r   r   r=   r<   r   r;   r   )rm   ro   r   
crypto_keyr\   r\   r]   rr     s(   

zECAlgorithm.prepare_keyrt   ra   r'   c                 C  s    | |t|  }t||jS r~   )rv   r!   rb   r   curve)rm   rt   ro   der_sigr\   r\   r]   rv     s   zECAlgorithm.sign'AllowedECKeys'rw   rx   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   rf   r'   r   rz   r!   rb   r   )rm   rt   ro   rw   r   r   r\   r\   r]   rz     s   
zECAlgorithm.verifyr   r{   r|   r   c                 C  r}   r~   r\   r   r\   r\   r]   r   )  r   zECAlgorithm.to_jwkFr   r   c                 C  r}   r~   r\   r   r\   r\   r]   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   )rf   r'   r   r   r)   r   r   r#   r$   r%   r"   r   r   r   r   r   private_valuer   r   )r   r{   r   r   r   r\   r\   r]   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 {})rf   r   r   r   r   r   r   r   r   lenr#   r$   r%   r"   r*   int
from_bytesr   r(   r   )r   r   r   r   r   	curve_objr   r   r\   r\   r]   r   Z  sv   



zECAlgorithm.from_jwkNr   )ro   r   rJ   r   )rt   ra   ro   r'   rJ   ra   )rt   ra   ro   r   rw   ra   rJ   rx   )r   r   r{   r|   rJ   r   r   )r   r   r{   r   rJ   r   )r   r   r{   rx   rJ   r   )r   r   rJ   r   )r   r   r   r   r   rR   r   rS   rT   r   rr   rv   rz   r   r   r   r   r\   r\   r\   r]   rX     s(   
 



&rX   c                   @  s$   e Zd ZdZdddZdddZdS )rY   zA
        Performs a signature using RSASSA-PSS with MGF1
        rt   ra   ro   r/   rJ   c                 C  s,   | |tjt|  |  jd|  S )Nmgfsalt_length)rv   r    PSSMGF1rb   digest_sizeru   r\   r\   r]   rv     s   zRSAPSSAlgorithm.signr1   rw   rx   c              	   C  sJ   z| ||tjt|  |  jd|   W dS  ty$   Y dS w )Nr   TF)rz   r    r   r   rb   r   r   ry   r\   r\   r]   rz     s   	zRSAPSSAlgorithm.verifyNr   r   )r   r   r   r   rv   rz   r\   r\   r\   r]   rY     s    

rY   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 )0rZ   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        kwargsr   rJ   r   c                 K  r}   r~   r\   )rm   r   r\   r\   r]   r     r   zOKPAlgorithm.__init__ro   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)rf   ra   r   r   encoder<   r;   r=   r-   r.   r+   r,   r   )rm   ro   key_strr   r\   r\   r]   rr     s"   

zOKPAlgorithm.prepare_keyrt   r   #Ed25519PrivateKey | Ed448PrivateKeyra   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  )rf   r   r  rv   )rm   rt   ro   	msg_bytesr\   r\   r]   rv     s   

zOKPAlgorithm.signrw   rx   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)rf   r   r  r-   r+   r   rz   r   )rm   rt   ro   rw   r  	sig_bytesr   r\   r\   r]   rz     s   
zOKPAlgorithm.verifyr{   r|   r   c                 C  r}   r~   r\   ro   r{   r\   r\   r]   r     r   zOKPAlgorithm.to_jwkFr   r   c                 C  r}   r~   r\   r
  r\   r\   r]   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  encryption_algorithm)r   r   r   r   r   )rf   r.   r,   public_bytesr7   Rawr:   r   r   r   r   r   r-   r+   private_bytesr9   r8   r   r   )ro   r{   r   r   r   r   r\   r\   r]   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)rf   r   r   r   r   r   r   r   r   r.   from_public_bytesr,   r-   from_private_bytesr+   )r   r   r   r   r   errr\   r\   r]   r   =  s>   



zOKPAlgorithm.from_jwkN)r   r   rJ   r   )ro   r  rJ   r  )rt   r   ro   r  rJ   ra   )rt   r   ro   r  rw   r   rJ   rx   )ro   r  r{   r|   rJ   r   r   )ro   r  r{   r   rJ   r   )ro   r  r{   rx   rJ   r   )r   r   rJ   r  )r   r   r   r   r   rr   rv   rz   r   r   r   r   r\   r\   r\   r]   rZ     s     



.rZ   )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   typing_extensionscryptography.exceptionsr   cryptography.hazmat.backendsr   cryptography.hazmat.primitivesr   )cryptography.hazmat.primitives.asymmetricr    ,cryptography.hazmat.primitives.asymmetric.ecr!   r"   r#   r$   r%   r&   r'   r(   r)   r*   /cryptography.hazmat.primitives.asymmetric.ed448r+   r,   1cryptography.hazmat.primitives.asymmetric.ed25519r-   r.   -cryptography.hazmat.primitives.asymmetric.rsar/   r0   r1   r2   r3   r4   r5   r6   ,cryptography.hazmat.primitives.serializationr7   r8   r9   r:   r;   r<   r=   rU   ModuleNotFoundErrorr   r   r  AllowedKeysAllowedPrivateKeysAllowedPublicKeysrequires_cryptographyr^   r_   rP   rQ   rW   rX   rY   rZ   r\   r\   r\   r]   <module>   sh    $,
0($


"KF & 7  