U
    Û@cj›t  ã                   @  sŠ  d dl m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 zØd d	lm Z 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,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d dlBmCZCmDZDmEZEmFZFmGZGmHZHmIZI dZJW n eKk
�r’   dZJY nX e	�ræe:e<B ZLe/e1B ZMe7e8B e4B e5B ZNeLeMB eNB ZOe:e/B e7B e4B ZPe<e1B e8B e5B ZQddddddddddddhZRd d!œd"d#„ZSG d$d%„ d%eƒZTG d&d'„ d'eTƒZUG d(d)„ d)eTƒZVeJ�r†G d*d+„ d+eTƒZWG d,d-„ d-eTƒZXG d.d/„ d/eWƒZYG d0d1„ d1eTƒZZdS )2é    )ÚannotationsN)ÚABCÚabstractmethod)ÚTYPE_CHECKINGÚAnyÚClassVarÚLiteralÚNoReturnÚ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)ÚInvalidSignatureÚUnsupportedAlgorithm)Ú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ÚRS256ÚRS384ÚRS512ÚES256ÚES256KÚES384ÚES521ÚES512ÚPS256ÚPS384ÚPS512ÚEdDSAzdict[str, Algorithm])Úreturnc                  C  s’   t ƒ ttjƒttjƒttjƒdœ} trŽ|  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)r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   )ÚNoneAlgorithmÚHMACAlgorithmÚSHA256ÚSHA384ÚSHA512Ú
has_cryptoÚupdateÚRSAAlgorithmÚECAlgorithmÚRSAPSSAlgorithmÚOKPAlgorithm)Zdefault_algorithms© rU   ú2/tmp/pip-unpacked-wheel-uvkk6i2w/jwt/algorithms.pyÚget_default_algorithmsi   s0    üÿòÿrW   c                   @  sÎ   e Zd ZdZdddœdd„Zedddœdd	„ƒZedddd
œdd„ƒZedddddœdd„ƒZe	e
edddœdd„ƒƒƒZe	e
ed!dddœdd„ƒƒƒZe
ed"dddœdd„ƒƒZe
edddœdd„ƒƒZd S )#Ú	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    Úbytes)ÚbytestrrH   c                 C  sn   t | ddƒ}|dkrt‚trZt|tƒrZt|tjƒrZtj|ƒ t	ƒ d�}| 
|¡ t| ¡ ƒS t||ƒ ¡ ƒS d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ÚNotImplementedErrorrO   Ú
isinstanceÚtypeÚ
issubclassr   ZHashAlgorithmZHashr   rP   rY   ÚfinalizeÚdigest)ÚselfrZ   r[   rc   rU   rU   rV   Úcompute_hash_digest�   s    ÿþ
ý
zAlgorithm.compute_hash_digestr   ©ÚkeyrH   c                 C  s   dS )zš
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        NrU   ©rd   rg   rU   rU   rV   Úprepare_key¦   s    zAlgorithm.prepare_key©Úmsgrg   rH   c                 C  s   dS )zn
        Returns a digital signature for the specified message
        using the specified key value.
        NrU   ©rd   rk   rg   rU   rU   rV   Úsign­   s    zAlgorithm.signÚbool©rk   rg   ÚsigrH   c                 C  s   dS )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        NrU   ©rd   rk   rg   rp   rU   rU   rV   Úverify´   s    zAlgorithm.verifyúLiteral[True]r   )Úas_dictrH   c                 C  s   d S ©NrU   ©Úkey_objrt   rU   rU   rV   Úto_jwk»   s    zAlgorithm.to_jwkFúLiteral[False]Ústrc                 C  s   d S ru   rU   rv   rU   rU   rV   rx   À   s    úJWKDict | strc                 C  s   dS )z3
        Serializes a given key into a JWK
        NrU   rv   rU   rU   rV   rx   Å   s    ústr | JWKDict©ÚjwkrH   c                 C  s   dS )zJ
        Deserializes a given key from JWK back into a key object
        NrU   ©r~   rU   rU   rV   Úfrom_jwkÌ   s    zAlgorithm.from_jwkN)F)F)Ú__name__Ú
__module__Ú__qualname__Ú__doc__re   r   ri   rm   rr   r   Ústaticmethodrx   r€   rU   rU   rU   rV   rX   ‹   s,   rX   c                   @  sr   e Zd ZdZdddœdd„Zddddœd	d
„Zdddddœdd„Zedddddœdd„ƒZedddœdd„ƒZ	dS )rJ   zZ
    Placeholder for use when no signing or verification
    operations are required.
    z
str | NoneÚNonerf   c                 C  s    |dkrd }|d k	rt dƒ‚|S )NÚ z*When alg = "none", key value must be None.r   rh   rU   rU   rV   ri   Ú   s
    zNoneAlgorithm.prepare_keyrY   rj   c                 C  s   dS )Nó    rU   rl   rU   rU   rV   rm   ã   s    zNoneAlgorithm.signrn   ro   c                 C  s   dS )NFrU   rq   rU   rU   rV   rr   æ   s    zNoneAlgorithm.verifyFr   r	   ©rw   rt   rH   c                 C  s
   t ƒ ‚d S ru   ©r^   rv   rU   rU   rV   rx   é   s    zNoneAlgorithm.to_jwkr|   r}   c                 C  s
   t ƒ ‚d S ru   rŠ   r   rU   rU   rV   r€   í   s    zNoneAlgorithm.from_jwkN)F)
r�   r‚   rƒ   r„   ri   rm   rr   r…   rx   r€   rU   rU   rU   rV   rJ   Ô   s   	rJ   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œd	d
„Zdddœdd„Zeeddddœdd„ƒƒZeed'ddddœdd„ƒƒZed(ddddœdd„ƒZedddœdd„ƒZdddd œd!d"„Zddddd#œd$d%„Zd&S ))rK   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rL   rM   rN   r   r†   ©r[   rH   c                 C  s
   || _ d S ru   ©r[   ©rd   r[   rU   rU   rV   Ú__init__ü   s    zHMACAlgorithm.__init__ústr | bytesrY   rf   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   ©rd   rg   Ú	key_bytesrU   rU   rV   ri   ÿ   s    ÿzHMACAlgorithm.prepare_keyrs   r   r‰   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx   
  s    zHMACAlgorithm.to_jwkFry   rz   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx     s    rn   r{   c                 C  s,   t t| ƒƒ ¡ ddœ}|r|S t |¡S d S )NÚoct)ÚkÚkty)r   r   ÚdecodeÚjsonÚdumps)rw   rt   r~   rU   rU   rV   rx     s    þr|   r}   c                 C  sn   z.t | tƒrt | ¡}nt | tƒr(| }nt‚W n tk
rJ   tdƒ‚Y nX | d¡dkrbtdƒ‚t|d ƒS )NúKey is not valid JSONr”   r’   zNot an HMAC keyr“   )	r_   rz   r–   ÚloadsÚdictÚ
ValueErrorr   Úgetr   )r~   ÚobjrU   rU   rV   r€   "  s    

zHMACAlgorithm.from_jwkrj   c                 C  s   t  ||| j¡ ¡ S ru   )ÚhmacÚnewr[   rc   rl   rU   rU   rV   rm   3  s    zHMACAlgorithm.signro   c                 C  s   t  ||  ||¡¡S ru   )rž   Úcompare_digestrm   rq   rU   rU   rV   rr   6  s    zHMACAlgorithm.verifyN)F)F)r�   r‚   rƒ   r„   ÚhashlibÚsha256rL   Ú__annotations__Úsha384rM   Úsha512rN   rŽ   ri   r   r…   rx   r€   rm   rr   rU   rU   rU   rV   rK   ò   s&   
 ÿrK   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œd	d
„Z	dddœdd„Z
eeddddœdd„ƒƒZeed*ddddœdd„ƒƒZed+ddddœdd„ƒZedddœdd„ƒZd d!d d"œd#d$„Zd d%d dd&œd'd(„Zd)S ),rQ   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        ú$ClassVar[type[hashes.HashAlgorithm]]rL   rM   rN   útype[hashes.HashAlgorithm]r†   r‹   c                 C  s
   || _ d S ru   rŒ   r�   rU   rU   rV   rŽ   F  s    zRSAAlgorithm.__init__zAllowedRSAKeys | str | bytesÚAllowedRSAKeysrf   c                 C  s²   t |ttfƒr|S t |ttfƒs(tdƒ‚t|ƒ}z2| d¡rLttt	|ƒƒW S ttt
|d d�ƒW S W nJ tk
r¬   zttt|ƒƒW  Y S  ttfk
r¦   tdƒ‚Y nX Y nX d S )NúExpecting a PEM-formatted key.s   ssh-rsa©Úpasswordz(Could not parse the provided public key.)r_   r-   r/   rY   rz   Ú	TypeErrorr   Ú
startswithr
   r;   r9   r›   r:   r   r   r�   rU   rU   rV   ri   I  s"    
 
ÿ
zRSAAlgorithm.prepare_keyrs   r   r‰   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx   _  s    zRSAAlgorithm.to_jwkFry   rz   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx   e  s    rn   r{   c                 C  sÞ   d }t | dƒrˆ|  ¡ }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ƒ‚|rÐ|S t |¡S d S )NÚprivate_numbersÚRSArm   )
r”   Úkey_opsÚnÚeÚdÚpÚqÚdpÚdqÚqirr   )r”   r°   r±   r²   úNot a public or private key)Úhasattrr®   r   Úpublic_numbersr±   r•   r²   r³   r´   rµ   Údmp1Údmq1Úiqmpr   r–   r—   )rw   rt   r�   ÚnumbersrU   rU   rV   rx   k  s2    
ö
ür|   r}   c           	   	     sÂ  z.t | tƒrt | ¡‰ nt | tƒr(| ‰ nt‚W n tk
rJ   tdƒ‚Y nX ˆ  d¡dkrbtdƒ‚dˆ k�r„dˆ k�r„dˆ k�r„dˆ kr�td	ƒ‚d
ddddg}‡ fdd„|D ƒ}t|ƒ}|rÌt	|ƒsÌtdƒ‚t
tˆ d ƒtˆ d ƒƒ}|�r4ttˆ d ƒtˆ d
 ƒtˆ d ƒtˆ d ƒtˆ d ƒtˆ d ƒ|d�}nHtˆ d ƒ}t|j||jƒ\}}t|||t||ƒt||ƒt||ƒ|d�}| ¡ S dˆ k�r¶dˆ k�r¶t
tˆ d ƒtˆ d ƒƒ ¡ S tdƒ‚d S )Nr˜   r”   r¯   zNot an RSA keyr³   r²   r±   Zothz5Unsupported RSA private key: > 2 primes not supportedr´   rµ   r¶   r·   r¸   c                   s   g | ]}|ˆ k‘qS rU   rU   )Ú.0Úprop©r�   rU   rV   Ú
<listcomp>©  s     z)RSAAlgorithm.from_jwk.<locals>.<listcomp>z@RSA key must include all parameters if any are present besides d)r³   r´   rµ   r¼   r½   r¾   r»   r¹   )r_   rz   r–   r™   rš   r›   r   rœ   ÚanyÚallr0   r   r.   r4   r±   r²   r1   r2   r3   Úprivate_keyÚ
public_key)	r~   Zother_propsZprops_foundZany_props_foundr»   r¿   r³   r´   rµ   rU   rÂ   rV   r€   ’  st    

ÿÿ

þ





ù
  ÿù


þzRSAAlgorithm.from_jwkrY   r-   rj   c                 C  s   |  |t ¡ |  ¡ ¡S ru   )rm   r   ÚPKCS1v15r[   rl   rU   rU   rV   rm   Ú  s    zRSAAlgorithm.signr/   ro   c                 C  s:   z|  ||t ¡ |  ¡ ¡ W dS  tk
r4   Y dS X d S )NTF)rr   r   rÈ   r[   r   rq   rU   rU   rV   rr   Ý  s
    zRSAAlgorithm.verifyN)F)F)r�   r‚   rƒ   r„   r   rL   r£   rM   rN   rŽ   ri   r   r…   rx   r€   rm   rr   rU   rU   rU   rV   rQ   <  s&   
 ÿ&G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œd	d
„Z	dddœdd„Z
ddddœdd„Zdddddœdd„Zeeddddœdd„ƒƒZeed)ddd dœd!d„ƒƒZed*ddd"dœd#d„ƒZed$dd%œd&d'„ƒZd(S )+rR   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r¦   rL   rM   rN   r§   r†   r‹   c                 C  s
   || _ d S ru   rŒ   r�   rU   rU   rV   rŽ   î  s    zECAlgorithm.__init__zAllowedECKeys | str | bytesÚAllowedECKeysrf   c                 C  sŒ   t |ttfƒr|S t |ttfƒs(tdƒ‚t|ƒ}z | d¡rFt|ƒ}nt	|ƒ}W n  t
k
rp   t|d d�}Y nX t |ttfƒsˆtdƒ‚|S )Nr©   s   ecdsa-sha2-rª   zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)r_   r%   r'   rY   rz   r¬   r   r­   r;   r:   r›   r9   r   )rd   rg   r‘   Z
crypto_keyrU   rU   rV   ri   ñ  s&    

 ÿÿzECAlgorithm.prepare_keyrY   r%   rj   c                 C  s    |  |t|  ¡ ƒ¡}t||jƒS ru   )rm   r   r[   r   Úcurve)rd   rk   rg   Úder_sigrU   rU   rV   rm     s    zECAlgorithm.signrn   ro   c                 C  sv   zt ||jƒ}W n tk
r&   Y dS X z2t|tƒr<| ¡ n|}| ||t|  ¡ ƒ¡ W dS  t	k
rp   Y dS X d S )NFT)
r   rÊ   r›   r_   r%   rÇ   rr   r   r[   r   )rd   rk   rg   rp   rË   rÇ   rU   rU   rV   rr     s    ÿ
ýzECAlgorithm.verifyrs   r   r‰   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx   %  s    zECAlgorithm.to_jwkFry   rz   c                 C  s   d S ru   rU   rv   rU   rU   rV   rx   +  s    r{   c                 C  sä   t | tƒr|  ¡  ¡ }nt | tƒr,|  ¡ }ntdƒ‚t | jtƒrFd}nFt | jtƒrXd}n4t | jt	ƒrjd}n"t | jt
ƒr|d}ntd| j› �ƒ‚d|t|jƒ ¡ t|jƒ ¡ dœ}t | tƒrÎt|  ¡ jƒ ¡ |d	< |rÖ|S t |¡S d S )
Nr¹   úP-256úP-384úP-521Ú	secp256k1úInvalid curve: ÚEC)r”   ÚcrvÚxÚyr³   )r_   r%   rÇ   r»   r'   r   rÊ   r!   r"   r#   r    r   rÓ   r•   rÔ   r®   Zprivate_valuer–   r—   )rw   rt   r»   rÒ   r�   rU   rU   rV   rx   1  s4    


ü
ÿr|   r}   c                 C  s$  z.t | tƒrt | ¡}nt | tƒr(| }nt‚W n tk
rJ   tdƒ‚Y nX | d¡dkrbtdƒ‚d|ksrd|krztdƒ‚t| d¡ƒ}t| d¡ƒ}| d¡}|dkrÚt	|ƒt	|ƒ  krÄd	krÐn nt
ƒ }ntd
ƒ‚nÎ|dk�rt	|ƒt	|ƒ  k�rdk�rn ntƒ }ntdƒ‚nŽ|dk�rZt	|ƒt	|ƒ  k�rDdk�rPn ntƒ }ntdƒ‚nN|dk�ršt	|ƒt	|ƒ  k�r„d	k�r�n ntƒ }ntdƒ‚ntd|› �ƒ‚ttj|dd�tj|dd�|d�}d|k�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 {})r_   rz   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³   rU   rU   rV   r€   V  sh    


 

$

$

$ÿý
  ÿ ÿzECAlgorithm.from_jwkN)F)F)r�   r‚   rƒ   r„   r   rL   r£   rM   rN   rŽ   ri   rm   rr   r   r…   rx   r€   rU   rU   rU   rV   rR   ä  s&   
 ÿ$rR   c                   @  s6   e Zd ZdZddddœdd„Zddddd	œd
d„ZdS )rS   zA
        Performs a signature using RSASSA-PSS with MGF1
        rY   r-   rj   c                 C  s,   |  |tjt |  ¡ ¡|  ¡ jd�|  ¡ ¡S )N©ZmgfZsalt_length)rm   r   ÚPSSÚMGF1r[   Údigest_sizerl   rU   rU   rV   rm   Ÿ  s    þúzRSAPSSAlgorithm.signr/   rn   ro   c              	   C  sP   z4|  ||tjt |  ¡ ¡|  ¡ jd�|  ¡ ¡ W dS  tk
rJ   Y dS X d S )NrÝ   TF)rr   r   rÞ   rß   r[   rà   r   rq   rU   rU   rV   rr   ©  s    þù	zRSAPSSAlgorithm.verifyN)r�   r‚   rƒ   r„   rm   rr   rU   rU   rU   rV   rS   š  s   
rS   c                   @  s¸   e Zd ZdZdddœdd„Zddd	œd
d„Zddddœdd„Zdddddœdd„Zee	ddddœdd„ƒƒZ
ee	d&ddddœdd„ƒƒZ
e	d'ddddœd d„ƒZ
e	d!dd"œd#d$„ƒZd%S )(rT   zŽ
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        r   r†   )ÚkwargsrH   c                 K  s   d S ru   rU   )rd   rá   rU   rU   rV   rŽ   ¿  s    zOKPAlgorithm.__init__zAllowedOKPKeys | str | bytesÚAllowedOKPKeysrf   c                 C  sœ   t |ttfƒr~t |tƒr"| d¡n|}t |tƒr:| d¡n|}d|krPt|ƒ}n.d|krft|d d�}n|dd… dkr~t|ƒ}t |tt	t
tfƒs˜tdƒ‚|S )	Núutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATErª   r   é   zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)r_   rY   rz   r•   Úencoder:   r9   r;   r+   r,   r)   r*   r   )rd   rg   Zkey_strr‘   rU   rU   rV   ri   Â  s"    

þÿzOKPAlgorithm.prepare_keyr�   z#Ed25519PrivateKey | Ed448PrivateKeyrY   rj   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ã   )r_   rz   rå   rm   )rd   rk   rg   Ú	msg_bytesrU   rU   rV   rm   Ù  s    
zOKPAlgorithm.signrn   ro   c                 C  sx   z\t |tƒr| d¡n|}t |tƒr.| d¡n|}t |ttfƒrH| ¡ n|}| ||¡ W dS  tk
rr   Y dS X dS )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ã   TFN)r_   rz   rå   r+   r)   rÇ   rr   r   )rd   rk   rg   rp   ræ   Z	sig_bytesrÇ   rU   rU   rV   rr   æ  s    ÿ
ýzOKPAlgorithm.verifyrs   r   )rg   rt   rH   c                 C  s   d S ru   rU   ©rg   rt   rU   rU   rV   rx      s    zOKPAlgorithm.to_jwkFry   rz   c                 C  s   d S ru   rU   rç   rU   rU   rV   rx     s    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œ}|rR|S t
 |¡S t | ttfƒrà| jtjtjtƒ d�}|  ¡ jtjtjd�}t | tƒr¤dnd}tt|ƒƒ 	¡ tt|ƒƒ 	¡ d|dœ}|rÖ|S t
 |¡S tdƒ‚d S )	N)ÚencodingÚformatÚEd25519ÚEd448ÚOKP)rÓ   r”   rÒ   )rè   ré   Zencryption_algorithm)rÓ   r³   r”   rÒ   r¹   )r_   r,   r*   Zpublic_bytesr5   ZRawr8   r   r   r•   r–   r—   r+   r)   Zprivate_bytesr7   r6   rÇ   r   )rg   rt   rÓ   rÒ   r�   r³   rU   rU   rV   rx     sB    þý
ýþü
r|   r}   c              
   C  s2  z.t | tƒrt | ¡}nt | tƒr(| }nt‚W n tk
rJ   tdƒ‚Y nX | d¡dkrbtdƒ‚| d¡}|dkrŠ|dkrŠtd|› �ƒ‚d	|krštd
ƒ‚t| d	¡ƒ}zVd|krÒ|dkrÆt	 
|¡W S t 
|¡W S t| d¡ƒ}|dkrôt |¡W S t |¡W S  tk
�r, } ztdƒ|‚W 5 d }~X Y nX d S )Nr˜   r”   rì   zNot an Octet Key PairrÒ   rê   rë   rÐ   rÓ   zOKP should have "x" parameterr³   zInvalid key parameter)r_   rz   r–   r™   rš   r›   r   rœ   r   r,   Zfrom_public_bytesr*   r+   Zfrom_private_bytesr)   )r~   r�   rÊ   rÓ   r³   ÚerrrU   rU   rV   r€   ;  s6    


zOKPAlgorithm.from_jwkN)F)F)r�   r‚   rƒ   r„   rŽ   ri   rm   rr   r   r…   rx   r€   rU   rU   rU   rV   rT   ¸  s     ÿ.rT   )[Ú
__future__r   r¡   rž   r–   Úabcr   r   Útypingr   r   r   r   r	   r
   r   Ú
exceptionsr   Útypesr   r   Úutilsr   r   r   r   r   r   r   r   r   Zcryptography.exceptionsr   r   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-   r.   r/   r0   r1   r2   r3   r4   Z,cryptography.hazmat.primitives.serializationr5   r6   r7   r8   r9   r:   r;   rO   ÚModuleNotFoundErrorr¨   rÉ   râ   ZAllowedKeysZAllowedPrivateKeysZAllowedPublicKeysZrequires_cryptographyrW   rX   rJ   rK   rQ   rR   rS   rT   rU   rU   rU   rV   Ú<module>   sn   $,0(
$

ÿÿÿô"IH ) 7