o
    "“iÉv  ã                   @  sp  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 zld 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 eKyÇ   dZJY nw e	rðe:e<B ZLe/e1B ZMe7e8B e4B e5B ZNeLeMB eNB ZOe:e/B e7B e4B ZPe<e1B e8B e5B ZQh d£ZRd'dd„ZSG dd„ deƒZTG dd„ deTƒZUG dd„ deTƒZVeJ�r6G dd „ d eTƒZWG d!d"„ d"eTƒZXG d#d$„ d$eWƒZYG d%d&„ d&eTƒZZdS dS )(é    )Ú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>   Ú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)rD   rE   rF   r<   rG   r=   r?   r>   rA   rB   rC   r@   )ÚNoneAlgorithmÚHMACAlgorithmÚSHA256ÚSHA384ÚSHA512Ú
has_cryptoÚupdateÚRSAAlgorithmÚECAlgorithmÚRSAPSSAlgorithmÚOKPAlgorithm)Údefault_algorithms© rZ   úN/var/www/html/premium_crap/venv/lib/python3.10/site-packages/jwt/algorithms.pyÚget_default_algorithmsi   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ÚbytesrH   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ÚNotImplementedErrorrS   Ú
isinstanceÚtypeÚ
issubclassr   ÚHashAlgorithmÚHashr   rT   r_   ÚfinalizeÚdigest)Úselfr^   r`   rj   rZ   rZ   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().
        NrZ   ©rk   rm   rZ   rZ   r[   Úprepare_key¦   ó    zAlgorithm.prepare_keyÚmsgc                 C  rn   )zn
        Returns a digital signature for the specified message
        using the specified key value.
        NrZ   ©rk   rr   rm   rZ   rZ   r[   Úsign­   rq   zAlgorithm.signÚsigÚboolc                 C  rn   )zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        NrZ   ©rk   rr   rm   ru   rZ   rZ   r[   Úverify´   rq   zAlgorithm.verifyÚas_dictúLiteral[True]r   c                 C  ó   d S ©NrZ   ©Úkey_objry   rZ   rZ   r[   Úto_jwk»   ó   zAlgorithm.to_jwkFúLiteral[False]Ústrc                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   À   r€   úJWKDict | strc                 C  rn   )z3
        Serializes a given key into a JWK
        NrZ   r}   rZ   rZ   r[   r   Å   rq   Újwkústr | JWKDictc                 C  rn   )zJ
        Deserializes a given key from JWK back into a key object
        NrZ   ©r„   rZ   rZ   r[   Úfrom_jwkÌ   rq   zAlgorithm.from_jwkN)r^   r_   rH   r_   )rm   r   rH   r   )rr   r_   rm   r   rH   r_   )rr   r_   rm   r   ru   r_   rH   rv   )ry   rz   rH   r   ©F)ry   r�   rH   r‚   )ry   rv   rH   rƒ   )r„   r…   rH   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rl   r   rp   rt   rx   r   Ústaticmethodr   r‡   rZ   rZ   rZ   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 )"rN   zZ
    Placeholder for use when no signing or verification
    operations are required.
    rm   ú
str | NonerH   ÚNonec                 C  s    |dkrd }|d urt dƒ‚|S )NÚ z*When alg = "none", key value must be None.r   ro   rZ   rZ   r[   rp   Ú   s
   zNoneAlgorithm.prepare_keyrr   r_   c                 C  rn   )Nó    rZ   rs   rZ   rZ   r[   rt   ã   ó   zNoneAlgorithm.signru   rv   c                 C  rn   )NFrZ   rw   rZ   rZ   r[   rx   æ   r’   zNoneAlgorithm.verifyFr~   r   ry   r	   c                 C  ó   t ƒ ‚r|   ©rc   r}   rZ   rZ   r[   r   é   ó   zNoneAlgorithm.to_jwkr„   r…   c                 C  r“   r|   r”   r†   rZ   rZ   r[   r‡   í   r•   zNoneAlgorithm.from_jwkN)rm   rŽ   rH   r�   )rr   r_   rm   r�   rH   r_   )rr   r_   rm   r�   ru   r_   rH   rv   rˆ   )r~   r   ry   rv   rH   r	   )r„   r…   rH   r	   )
r‰   rŠ   r‹   rŒ   rp   rt   rx   r�   r   r‡   rZ   rZ   rZ   r[   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,d-dd„ƒƒZed,d.dd„ƒZed/d d!„ƒZd0d#d$„Zd1d&d'„Zd(S )2rO   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]rP   rQ   rR   r`   r   rH   r�   c                 C  ó
   || _ d S r|   ©r`   ©rk   r`   rZ   rZ   r[   Ú__init__ü   ó   
zHMACAlgorithm.__init__rm   ú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   ©rk   rm   Ú	key_bytesrZ   rZ   r[   rp   ÿ   s   ÿzHMACAlgorithm.prepare_keyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   
  ó   zHMACAlgorithm.to_jwkFr�   r‚   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r     rž   rv   rƒ   c                 C  s(   t t| ƒƒ ¡ ddœ}|r|S t |¡S )NÚoct)ÚkÚkty)r   r   ÚdecodeÚjsonÚdumps)r~   ry   r„   rZ   rZ   r[   r     s   þ
r„   r…   c                 C  sj   zt | tƒrt | ¡}n
t | tƒr| }nt‚W n ty#   tdƒd ‚w | d¡dkr/tdƒ‚t|d ƒS )NúKey is not valid JSONr¡   rŸ   zNot an HMAC keyr    )	rd   r‚   r£   ÚloadsÚdictÚ
ValueErrorr   Úgetr   )r„   ÚobjrZ   rZ   r[   r‡   "  s   

€
ÿzHMACAlgorithm.from_jwkrr   c                 C  s   t  ||| j¡ ¡ S r|   )ÚhmacÚnewr`   rj   rs   rZ   rZ   r[   rt   3  ó   zHMACAlgorithm.signru   c                 C  s   t  ||  ||¡¡S r|   )r«   Úcompare_digestrt   rw   rZ   rZ   r[   rx   6  r­   zHMACAlgorithm.verifyN)r`   r   rH   r�   )rm   r›   rH   r_   )r~   r›   ry   rz   rH   r   rˆ   )r~   r›   ry   r�   rH   r‚   )r~   r›   ry   rv   rH   rƒ   )r„   r…   rH   r_   )rr   r_   rm   r_   rH   r_   )rr   r_   rm   r_   ru   r_   rH   rv   )r‰   rŠ   r‹   rŒ   ÚhashlibÚsha256rP   Ú__annotations__Úsha384rQ   Úsha512rR   r™   rp   r   r�   r   r‡   rt   rx   rZ   rZ   rZ   r[   rO   ò   s(   
 

ÿ
rO   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 )5rU   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        ú$ClassVar[type[hashes.HashAlgorithm]]rP   rQ   rR   r`   útype[hashes.HashAlgorithm]rH   r�   c                 C  r–   r|   r—   r˜   rZ   rZ   r[   r™   F  rš   zRSAAlgorithm.__init__rm   ú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yO   z
ttt|ƒƒW  Y S  ttfyN   tdƒd ‚w w )NúExpecting a PEM-formatted key.s   ssh-rsa©Úpasswordz(Could not parse the provided public key.)rd   r-   r/   r_   r‚   Ú	TypeErrorr   Ú
startswithr
   r;   r9   r¨   r:   r   r   rœ   rZ   rZ   r[   rp   I  s,   
ÿÿþÿýzRSAAlgorithm.prepare_keyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   a  rž   zRSAAlgorithm.to_jwkFr�   r‚   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   g  rž   rv   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ÚRSArt   )
r¡   Úkey_opsÚnÚeÚdÚpÚqÚdpÚdqÚqirx   )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~   ry   rª   ÚnumbersrZ   rZ   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ƒd ‚w ˆ  d¡dkr0tdƒd ‚dˆ v r¾dˆ v r¾dˆ v r¾dˆ v rDtd	ƒ‚g d
¢}‡ fdd„|D ƒ}t|ƒ}|r`t	|ƒs`tdƒ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 rZ   rZ   )Ú.0Úprop©rª   rZ   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È   )rd   r‚   r£   r¦   r§   r¨   r   r©   ÚanyÚallr0   r   r.   r4   rÀ   rÁ   r1   r2   r3   Úprivate_keyÚ
public_key)	r„   Úother_propsÚprops_foundÚany_props_foundrÊ   rÎ   rÂ   rÃ   rÄ   rZ   rÒ   r[   r‡   ”  s~   

€
ÿ
ÿÿþ

þ





ùñ
ÿù


þýzRSAAlgorithm.from_jwkrr   r_   r-   c                 C  s   |  |t ¡ |  ¡ ¡S r|   )rt   r   ÚPKCS1v15r`   rs   rZ   rZ   r[   rt   Ü  s   zRSAAlgorithm.signr/   ru   c                 C  s4   z|  ||t ¡ |  ¡ ¡ W dS  ty   Y dS w )NTF)rx   r   rÛ   r`   r   rw   rZ   rZ   r[   rx   ß  s   ÿzRSAAlgorithm.verifyN©r`   rµ   rH   r�   )rm   r¶   rH   r·   )r~   r·   ry   rz   rH   r   rˆ   )r~   r·   ry   r�   rH   r‚   )r~   r·   ry   rv   rH   rƒ   )r„   r…   rH   r·   ©rr   r_   rm   r-   rH   r_   ©rr   r_   rm   r/   ru   r_   rH   rv   )r‰   rŠ   r‹   rŒ   r   rP   r±   rQ   rR   r™   rp   r   r�   r   r‡   rt   rx   rZ   rZ   rZ   r[   rU   <  s(   
 

ÿ&
GrU   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d/dd„ƒƒZee	 d0d1d#d„ƒƒZed0d2d%d„ƒZed3d(d)„ƒZd*S )4rV   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r´   rP   rQ   rR   r`   rµ   rH   r�   c                 C  r–   r|   r—   r˜   rZ   rZ   r[   r™   ð  rš   zECAlgorithm.__init__rm   ú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ƒsDtdƒd ‚|S )Nr¸   s   ecdsa-sha2-r¹   zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)rd   r%   r'   r_   r‚   r»   r   r¼   r;   r:   r¨   r9   r   )rk   rm   r�   Ú
crypto_keyrZ   rZ   r[   rp   ó  s,   

€ÿÿÿþzECAlgorithm.prepare_keyrr   r_   r%   c                 C  s    |  |t|  ¡ ƒ¡}t||jƒS r|   )rt   r   r`   r   Úcurve)rk   rr   rm   Úder_sigrZ   rZ   r[   rt     s   zECAlgorithm.signru   rv   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¨   rd   r%   r×   rx   r   r`   r   )rk   rr   rm   ru   rã   r×   rZ   rZ   r[   rx     s   ÿ
ÿýÿzECAlgorithm.verifyr~   ry   rz   r   c                 C  r{   r|   rZ   r}   rZ   rZ   r[   r   '  rž   zECAlgorithm.to_jwkFr�   r‚   c                 C  r{   r|   rZ   r}   rZ   rZ   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| jjd� ¡ t|j| jjd� ¡ d	œ}t | tƒrst|  ¡ j| jjd� ¡ |d
< |rw|S t |¡S )NrÈ   úP-256úP-384úP-521Ú	secp256k1úInvalid curve: ÚEC)Ú
bit_length)r¡   ÚcrvÚxÚyrÂ   )rd   r%   r×   rÊ   r'   r   râ   r!   r"   r#   r    r   rì   Úkey_sizer¢   rí   r½   Úprivate_valuer£   r¤   )r~   ry   rÊ   rë   rª   rZ   rZ   r[   r   3  sJ   


þþö
þý
r„   r…   c                 C  s  zt | tƒrt | ¡}n
t | tƒr| }nt‚W n ty#   tdƒd ‚w | d¡dkr0tdƒd ‚d|vs8d|vr=tdƒd ‚t| d¡ƒ}t| d¡ƒ}| d¡}|dkrmt	|ƒt	|ƒ  krbd	krhn nt
ƒ }netd
ƒd ‚|dkrŠt	|ƒt	|ƒ  krdkr…n ntƒ }nHtdƒd ‚|dkr§t	|ƒt	|ƒ  krœdkr¢n ntƒ }n+tdƒd ‚|dkrÆt	|ƒt	|ƒ  kr¹d	krÂn 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 {})rd   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Â   rZ   rZ   r[   r‡   _  sˆ   

€
ÿ


 ÿþ ÿþ ÿþÿþÿý
ÿÿþzECAlgorithm.from_jwkNrÜ   )rm   rß   rH   rà   )rr   r_   rm   r%   rH   r_   )rr   r_   rm   rà   ru   r_   rH   rv   )r~   rà   ry   rz   rH   r   rˆ   )r~   rà   ry   r�   rH   r‚   )r~   rà   ry   rv   rH   rƒ   )r„   r…   rH   rà   )r‰   rŠ   r‹   rŒ   r   rP   r±   rQ   rR   r™   rp   rt   rx   r   r�   r   r‡   rZ   rZ   rZ   r[   rV   æ  s(   
 



ÿ+rV   c                   @  s$   e Zd ZdZddd„Zddd„ZdS )rW   zA
        Performs a signature using RSASSA-PSS with MGF1
        rr   r_   rm   r-   rH   c                 C  s,   |  |tjt |  ¡ ¡|  ¡ jd�|  ¡ ¡S )N©ÚmgfÚsalt_length)rt   r   ÚPSSÚMGF1r`   Údigest_sizers   rZ   rZ   r[   rt   ®  s   þúzRSAPSSAlgorithm.signr/   ru   rv   c              	   C  sJ   z|  ||tjt |  ¡ ¡|  ¡ jd�|  ¡ ¡ W dS  ty$   Y dS w )Nrù   TF)rx   r   rü   rý   r`   rþ   r   rw   rZ   rZ   r[   rx   ¸  s   þù	ÿzRSAPSSAlgorithm.verifyNrÝ   rÞ   )r‰   rŠ   r‹   rŒ   rt   rx   rZ   rZ   rZ   r[   rW   ©  s    

rW   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 )0rX   zŽ
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        Úkwargsr   rH   r�   c                 K  r{   r|   rZ   )rk   rÿ   rZ   rZ   r[   r™   Î  r’   zOKPAlgorithm.__init__rm   ú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)rd   r_   r‚   r¢   Úencoder:   r9   r;   r+   r,   r)   r*   r   )rk   rm   Úkey_strr�   rZ   rZ   r[   rp   Ñ  s"   

þÿzOKPAlgorithm.prepare_keyrr   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  )rd   r‚   r  rt   )rk   rr   rm   Ú	msg_bytesrZ   rZ   r[   rt   è  s   

zOKPAlgorithm.signru   rv   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)rd   r‚   r  r+   r)   r×   rx   r   )rk   rr   rm   ru   r  Ú	sig_bytesr×   rZ   rZ   r[   rx   õ  s   
ÿýÿzOKPAlgorithm.verifyry   rz   r   c                 C  r{   r|   rZ   ©rm   ry   rZ   rZ   r[   r     rž   zOKPAlgorithm.to_jwkFr�   r‚   c                 C  r{   r|   rZ   r	  rZ   rZ   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È   )rd   r,   r*   Úpublic_bytesr5   ÚRawr8   r   r   r¢   r£   r¤   r+   r)   Úprivate_bytesr7   r6   r×   r   )rm   ry   rì   rë   rª   rÂ   rZ   rZ   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ƒd ‚w | d¡dkr/tdƒ‚| d¡}|dkrC|dkrCtd|› �ƒ‚d	|vrKtd
ƒ‚t| d	¡ƒ}z+d|vrg|dkrat	 
|¡W S t 
|¡W S t| d¡ƒ}|dkrxt |¡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)rd   r‚   r£   r¦   r§   r¨   r   r©   r   r,   Úfrom_public_bytesr*   r+   Úfrom_private_bytesr)   )r„   rª   râ   rì   rÂ   ÚerrrZ   rZ   r[   r‡   J  s>   

€
ÿ

€ÿzOKPAlgorithm.from_jwkN)rÿ   r   rH   r�   )rm   r   rH   r  )rr   r›   rm   r  rH   r_   )rr   r›   rm   r  ru   r›   rH   rv   )rm   r  ry   rz   rH   r   rˆ   )rm   r  ry   r�   rH   r‚   )rm   r  ry   rv   rH   rƒ   )r„   r…   rH   r  )r‰   rŠ   r‹   rŒ   r™   rp   rt   rx   r   r�   r   r‡   rZ   rZ   rZ   r[   rX   Ç  s"    



ÿ.rX   )rH   rI   )[Ú
__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   Úcryptography.exceptionsr   r   Ú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-   r.   r/   r0   r1   r2   r3   r4   Ú,cryptography.hazmat.primitives.serializationr5   r6   r7   r8   r9   r:   r;   rS   ÚModuleNotFoundErrorr·   rà   r  ÚAllowedKeysÚAllowedPrivateKeysÚAllowedPublicKeysÚrequires_cryptographyr\   r]   rN   rO   rU   rV   rW   rX   rZ   rZ   rZ   r[   Ú<module>   sb    $,0($

ÿÿÿÿ
"IH + D � � �ð