o
    WÐjEg  ã                   @   sº  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	m
Z
mZmZmZmZ zdd dlZd dlmZmZ d dlmZ d dlmZ d dlmZmZ d d	lmZmZ d d
lmZ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* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 dZ4W n e5y—   dZ4Y nw h d£Z6dd„ Z7G dd„ dƒZ8G dd„ de8ƒZ9G dd„ de8ƒZ:e4rÛG dd„ de8ƒZ;G dd„ de8ƒZ<G dd„ de;ƒZ=G dd „ d e8ƒZ>dS dS )!é    Né   ©ÚInvalidKeyError)	Ú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)ÚInvalidSignatureÚUnsupportedAlgorithm)Úx509)Úhashes)ÚecÚpadding)ÚEllipticCurvePrivateKeyÚEllipticCurvePublicKey)Ú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_der_public_keyÚload_pem_private_keyÚload_pem_public_keyÚload_ssh_public_keyTF>   ÚES256ÚES384ÚES512ÚES521ÚEdDSAÚPS256ÚPS384ÚPS512ÚRS256ÚRS384ÚRS512ÚES256Kc                  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)r2   r3   r4   r*   r5   r+   r-   r,   r/   r0   r1   r.   )ÚNoneAlgorithmÚHMACAlgorithmÚSHA256ÚSHA384ÚSHA512Ú
has_cryptoÚupdateÚRSAAlgorithmÚECAlgorithmÚRSAPSSAlgorithmÚOKPAlgorithm)Údefault_algorithms© rF   ú0/usr/lib/python3/dist-packages/jwt/algorithms.pyÚget_default_algorithmsM   s0   üÿòÿrH   c                   @   s@   e Zd ZdZdd„ Zdd„ Zdd„ Zedd	„ ƒZed
d„ ƒZ	dS )Ú	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    c                 C   ó   t ‚)zš
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        ©ÚNotImplementedError©ÚselfÚkeyrF   rF   rG   Úprepare_keyt   ó   zAlgorithm.prepare_keyc                 C   rJ   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        rK   ©rN   ÚmsgrO   rF   rF   rG   Úsign{   rQ   zAlgorithm.signc                 C   rJ   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        rK   ©rN   rS   rO   ÚsigrF   rF   rG   Úverify‚   rQ   zAlgorithm.verifyc                 C   rJ   )z7
        Serializes a given RSA key into a JWK
        rK   ©Úkey_objrF   rF   rG   Úto_jwk‰   rQ   zAlgorithm.to_jwkc                 C   rJ   )zb
        Deserializes a given RSA key from JWK back into a PublicKey or PrivateKey object
        rK   )ÚjwkrF   rF   rG   Úfrom_jwk�   rQ   zAlgorithm.from_jwkN)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__rP   rT   rW   ÚstaticmethodrZ   r\   rF   rF   rF   rG   rI   o   s    
rI   c                   @   s(   e Zd ZdZdd„ Zdd„ Zdd„ ZdS )	r:   zZ
    Placeholder for use when no signing or verification
    operations are required.
    c                 C   s    |dkrd }|d urt dƒ‚|S )NÚ z*When alg = "none", key value must be None.r   rM   rF   rF   rG   rP   ž   s
   zNoneAlgorithm.prepare_keyc                 C   ó   dS )Nó    rF   rR   rF   rF   rG   rT   §   ó   zNoneAlgorithm.signc                 C   rc   )NFrF   rU   rF   rF   rG   rW   ª   re   zNoneAlgorithm.verifyN)r]   r^   r_   r`   rP   rT   rW   rF   rF   rF   rG   r:   ˜   s
    	r:   c                   @   sp   e Zd ZdZejZejZej	Z
dd„ Zededefdd„ƒZdd	„ Zed
d„ ƒZedd„ ƒZdd„ Zdd„ ZdS )r;   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    c                 C   ó
   || _ d S ©N©Úhash_alg©rN   ri   rF   rF   rG   Ú__init__¸   ó   
zHMACAlgorithm.__init__Ú	key_bytesÚreturnc              
   C   s\   t sdS zt| ƒ W dS  tttfy   Y nw zt | ¡ W dS  tttfy-   Y dS w ©NFT)r?   r&   Ú	TypeErrorÚ
ValueErrorr   r   Úload_der_x509_certificate)rm   rF   rF   rG   Ú_is_der_keyº   s   
ýÿýÿzHMACAlgorithm._is_der_keyc                 C   sx  t |ƒ}t|ƒdkrtdƒ‚t|ƒst|ƒs|  |¡rtdƒ‚ztj|dd„ d�}W nØ ty÷   z|j	t 
|¡dd�}W n tyH   d	}Y nw | d
¡}d}d}|t|ƒk râ|| dkrc|d7 }qR|d }|t|ƒk r‰|| dkrx|d7 }n|| dkrn
|d7 }|t|ƒk sm|t|ƒkr�nR|d }|t|ƒk r°|| dv r°|d7 }|t|ƒk r°|| dv s |t|ƒk rØ|| dkrØzt |||d … ¡dk}W n	 tyÔ   Y nw |rØn
|d }|t|ƒk sX| d¡sî| d¡ró|rótdƒd ‚d }Y n t�y   d }Y nw d}	|g}
|
�r3|
 ¡ }t|tƒ�r%d|v �rd}	n|
 | ¡ ¡ nt|tƒ�r0|
 |¡ |
�s|	�r:tdƒ‚|S )Nr   zHMAC key must not be empty.zdThe specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.c                 S   rc   )Nr   rF   )Ú_rF   rF   rG   Ú<lambda>á   s    z+HMACAlgorithm.prepare_key.<locals>.<lambda>)Ú	parse_intÚsurrogatepass)Úerrorsrb   u   ï»¿ 	
Fú"r   ú\é   z 	
ú:Úktyú{ú[z‡The specified key looks like a JWK and should not be used directly as an HMAC secret. Load it via PyJWK / HMACAlgorithm.from_jwk first.T)r   Úlenr   r
   r   rs   ÚjsonÚloadsÚRecursionErrorÚdecodeÚdetect_encodingÚUnicodeErrorÚlstriprq   Ú
startswithÚpopÚ
isinstanceÚdictÚextendÚvaluesÚlist)rN   rO   Újwk_objÚdecoded_keyÚstripped_keyÚhas_jwk_memberÚindexÚendÚ
next_indexÚcontains_jwk_memberÚobjects_to_checkÚobjrF   rF   rG   rP   Í   s¶   ÿ

ÿÿ

úÿþýÿþÿþÿä
ÿÿÿüÿ

ø	ÿzHMACAlgorithm.prepare_keyc                 C   s   t  tt| ƒƒ ¡ ddœ¡S )NÚoct)Úkr}   )r�   Údumpsr   r   r„   rX   rF   rF   rG   rZ   '  s
   þÿzHMACAlgorithm.to_jwkc                 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š   )	rŠ   Ústrr�   r‚   r‹   rq   r   Úgetr   )r[   r˜   rF   rF   rG   r\   0  s   

€ÿzHMACAlgorithm.from_jwkc                 C   s   t  ||| j¡ ¡ S rg   )ÚhmacÚnewri   ÚdigestrR   rF   rF   rG   rT   A  ó   zHMACAlgorithm.signc                 C   s   t  ||  ||¡¡S rg   )rŸ   Úcompare_digestrT   rU   rF   rF   rG   rW   D  r¢   zHMACAlgorithm.verifyN)r]   r^   r_   r`   ÚhashlibÚsha256r<   Úsha384r=   Úsha512r>   rk   ra   ÚbytesÚboolrs   rP   rZ   r\   rT   rW   rF   rF   rF   rG   r;   ®   s    Z

r;   c                   @   sZ   e Zd ZdZejZejZejZdd„ Zdd„ Z	e
dd„ ƒZe
dd	„ ƒZd
d„ Zdd„ ZdS )rA   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        c                 C   rf   rg   rh   rj   rF   rF   rG   rk   T  rl   zRSAAlgorithm.__init__c                 C   sx   t |ttfƒr	|S t |ttfƒstdƒ‚t|ƒ}z| d¡r%t|ƒ}W |S t	|d d�}W |S  t
y;   t|ƒ}Y |S w )NúExpecting a PEM-formatted key.s   ssh-rsa©Úpassword)rŠ   r   r   r¨   r�   rp   r   rˆ   r)   r'   rq   r(   rM   rF   rF   rG   rP   W  s   

ýþ
þzRSAAlgorithm.prepare_keyc                 C   sÖ   d }t | dd ƒrE|  ¡ }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d ƒrb|  ¡ }ddgt|jƒ ¡ t|jƒ ¡ dœ}ntdƒ‚t |¡S )NÚprivate_numbersÚRSArT   )
r}   Úkey_opsÚnÚeÚdÚpÚqÚdpÚdqÚqirW   )r}   r¯   r°   r±   úNot a public or private key)Úgetattrr­   r   Úpublic_numbersr°   r„   r±   r²   r³   r´   Údmp1Údmq1Úiqmpr   r�   r›   )rY   r˜   ÚnumbersrF   rF   rG   rZ   i  s.   öü
zRSAAlgorithm.to_jwkc           	   	      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 r»dˆ v r»dˆ v r»dˆ v rBtd	ƒ‚g d
¢}‡ fdd„|D ƒ}t|ƒ}|r]t	|ƒs]tdƒ‚t
tˆ d ƒtˆ d ƒƒ}|r“t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 rÔdˆ v rÔt
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 rF   rF   )Ú.0Úprop©r˜   rF   rG   Ú
<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¸   )rŠ   r�   r�   r‚   r‹   rq   r   rž   ÚanyÚallr   r	   r   r!   r°   r±   r   r   r    Úprivate_keyÚ
public_key)	r[   Úother_propsÚprops_foundÚany_props_foundrº   r¾   r²   r³   r´   rF   rÂ   rG   r\   �  sx   

€ÿÿÿ

þ





ùñ
ÿù


þzRSAAlgorithm.from_jwkc                 C   s   |  |t ¡ |  ¡ ¡S rg   )rT   r   ÚPKCS1v15ri   rR   rF   rF   rG   rT   ×  s   zRSAAlgorithm.signc                 C   s4   z|  ||t ¡ |  ¡ ¡ W dS  ty   Y dS w )NTF)rW   r   rË   ri   r   rU   rF   rF   rG   rW   Ú  s   ÿzRSAAlgorithm.verifyN)r]   r^   r_   r`   r   r<   r=   r>   rk   rP   ra   rZ   r\   rT   rW   rF   rF   rF   rG   rA   J  s    
#
IrA   c                   @   sN   e Zd ZdZejZejZejZdd„ Zdd„ Z	dd„ Z
dd	„ Zed
d„ ƒZdS )rB   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        c                 C   rf   rg   rh   rj   rF   rF   rG   rk   ë  rl   zECAlgorithm.__init__c                 C   sx   t |ttfƒr	|S t |ttfƒstdƒ‚t|ƒ}z| d¡r%t|ƒ}W |S t	|ƒ}W |S  t
y;   t|d d�}Y |S w )Nrª   s   ecdsa-sha2-r«   )rŠ   r   r   r¨   r�   rp   r   rˆ   r)   r(   rq   r'   rM   rF   rF   rG   rP   î  s   


üýýzECAlgorithm.prepare_keyc                 C   s"   |  |t |  ¡ ¡¡}t||jƒS rg   )rT   r   ÚECDSAri   r   Úcurve)rN   rS   rO   Úder_sigrF   rF   rG   rT     s   zECAlgorithm.signc                 C   sl   zt ||jƒ}W n
 ty   Y dS w zt|tƒr| ¡ }| ||t |  	¡ ¡¡ W dS  t
y5   Y dS w ro   )r   rÍ   rq   rŠ   r   rÇ   rW   r   rÌ   ri   r   )rN   rS   rO   rV   rÎ   rF   rF   rG   rW   	  s   ÿ
ÿzECAlgorithm.verifyc                 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rmt	|ƒt	|ƒ  kr_d	krin td
ƒ‚t
 ¡ }nktd
ƒ‚|dkr�t	|ƒt	|ƒ  krdkr‰n tdƒ‚t
 ¡ }nKtdƒ‚|dkr­t	|ƒt	|ƒ  krŸdkr©n tdƒ‚t
 ¡ }n+tdƒ‚|dkrÍt	|ƒt	|ƒ  kr¿d	krÉn tdƒ‚t
 ¡ }ntdƒ‚td|› �ƒ‚t
j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}   ÚECzNot an Elliptic curve keyÚxÚyÚcrvzP-256é    z)Coords should be 32 bytes for curve P-256zP-384é0   z)Coords should be 48 bytes for curve P-384zP-521éB   z)Coords should be 66 bytes for curve P-521Ú	secp256k1z-Coords should be 32 bytes for curve secp256k1úInvalid curve: Úbig)Ú	byteorder)rÐ   rÑ   rÍ   r²   z!D should be {} bytes for curve {})rŠ   r�   r�   r‚   r‹   rq   r   rž   r   r€   r   Ú	SECP256R1Ú	SECP384R1Ú	SECP521R1Ú	SECP256K1ÚEllipticCurvePublicNumbersÚintÚ
from_bytesrÇ   ÚEllipticCurvePrivateNumbersrÆ   )r[   r˜   rÐ   rÑ   rÍ   Ú	curve_objrº   r²   rF   rF   rG   r\     sv   

€ÿ

þ
þ
þÿ
þÿý
ÿÿþzECAlgorithm.from_jwkN)r]   r^   r_   r`   r   r<   r=   r>   rk   rP   rT   rW   ra   r\   rF   rF   rF   rG   rB   á  s    rB   c                   @   s    e Zd ZdZdd„ Zdd„ ZdS )rC   zA
        Performs a signature using RSASSA-PSS with MGF1
        c                 C   s*   |  |tjt |  ¡ ¡| jjd�|  ¡ ¡S )N©ÚmgfÚsalt_length)rT   r   ÚPSSÚMGF1ri   Údigest_sizerR   rF   rF   rG   rT   ^  s   þúzRSAPSSAlgorithm.signc              	   C   sH   z|  ||tjt |  ¡ ¡| jjd�|  ¡ ¡ W dS  ty#   Y dS w )Nrã   TF)rW   r   ræ   rç   ri   rè   r   rU   rF   rF   rG   rW   h  s   þù	ÿzRSAPSSAlgorithm.verifyN)r]   r^   r_   r`   rT   rW   rF   rF   rF   rG   rC   Y  s    
rC   c                   @   sH   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zed
d„ ƒZ	edd„ ƒZ
dS )rD   zŽ
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        c                 K   s   d S rg   rF   )rN   ÚkwargsrF   rF   rG   rk   ~  re   zOKPAlgorithm.__init__c                 C   sŠ   t |ttfƒr6t |tƒr| d¡}| d¡}d|v rt|ƒ}nd|v r*t|d d�}n|dd… dkr6t|ƒ}t |tt	t
tfƒsCtdƒ‚|S )	Núutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr«   r   é   zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)rŠ   r¨   r�   Úencoder„   r(   r'   r)   r   r   r   r   r   )rN   rO   Ústr_keyrF   rF   rG   rP   �  s$   




þÿzOKPAlgorithm.prepare_keyc                 C   s$   t |ƒturt|dƒn|}| |¡S )aR  
            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` iinstance
            :return bytes signature: The signature, as bytes
            rê   )Útyper¨   rT   rR   rF   rF   rG   rT   ™  s   
zOKPAlgorithm.signc                 C   sv   z.t |ƒturt|dƒn|}t |ƒturt|dƒn|}t|ttfƒr&| ¡ }| ||¡ W dS  tjj	y:   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)
rî   r¨   rŠ   r   r   rÇ   rW   ÚcryptographyÚ
exceptionsr   rU   rF   rF   rG   rW   ¤  s   
ÿzOKPAlgorithm.verifyc                 C   sÐ   t | ttfƒr(| jtjtjd�}t | tƒrdnd}t t	t
|ƒƒ ¡ d|dœ¡S t | ttfƒrd| jtjtjtƒ d�}|  ¡ jtjtjd�}t | tƒrLdnd}t t	t
|ƒƒ ¡ t	t
|ƒƒ ¡ d|dœ¡S tdƒ‚)	N©ÚencodingÚformatÚEd25519ÚEd448ÚOKP)rÐ   r}   rÒ   )rò   ró   Úencryption_algorithm)rÐ   r²   r}   rÒ   r¸   )rŠ   r   r   Úpublic_bytesr"   ÚRawr%   r�   r›   r   r   r„   r   r   Úprivate_bytesr$   r#   rÇ   r   )rO   rÐ   rÒ   r²   rF   rF   rG   rZ   ¹  s>   þýÿýþüÿ	zOKPAlgorithm.to_jwkc              
   C   sB  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 |¡}nt |¡}| ¡ jtjtjd�|kr�tdƒ‚|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²   rñ   z%Public key does not match private keyzInvalid key parameter)rŠ   r�   r�   r‚   r‹   rq   r   rž   r   r   Úfrom_public_bytesr   r   Úfrom_private_bytesr   rÇ   rø   r"   rù   r%   )r[   r˜   rÍ   rÐ   r²   rÆ   ÚerrrF   rF   rG   r\   á  sL   

€ÿ

ÿý
€ÿzOKPAlgorithm.from_jwkN)r]   r^   r_   r`   rk   rP   rT   rW   ra   rZ   r\   rF   rF   rF   rG   rD   w  s    
'rD   )?r¤   rŸ   r�   rð   r   Úutilsr   r   r   r   r	   r
   r   r   r   Úcryptography.exceptionsrï   r   r   r   Úcryptography.hazmat.primitivesr   Ú)cryptography.hazmat.primitives.asymmetricr   r   Ú,cryptography.hazmat.primitives.asymmetric.ecr   r   Ú/cryptography.hazmat.primitives.asymmetric.ed448r   r   Ú1cryptography.hazmat.primitives.asymmetric.ed25519r   r   Ú-cryptography.hazmat.primitives.asymmetric.rsar   r   r   r   r   r   r    r!   Ú,cryptography.hazmat.primitives.serializationr"   r#   r$   r%   r&   r'   r(   r)   r?   ÚModuleNotFoundErrorÚrequires_cryptographyrH   rI   r:   r;   rA   rB   rC   rD   rF   rF   rF   rG   Ú<module>   sF    ,((
ÿ")  x � �Ï