
    Pǻi                       U d dl mZ d dl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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" 	 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 d dl7m8Z8m9Z9 d dl:m;Z;m<Z< d dl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE d dlFmGZGmHZHmIZImJZJmKZKmLZLmMZM ej                  dk\  rd dl
mOZO nd dlPmOZO ee>e@f   ZQdeRd<   ee3e5f   ZSdeRd<   ee;e<e8e9f   ZTdeRd<   eeQeSeTf   ZUdeRd<   ee>e3e;e8f   ZVdeRd<   ee@e5e<e9f   ZWdeRd<   es eX ej                  dd            rd dlZm[Z[m\Z\ dZ]h d"Z`d2d#Za G d$ d%e      Zb G d& d'eb      Zc G d( d)eb      Zde]r- G d* d+eb      Ze G d, d-eb      Zf G d. d/ee      Zg G d0 d1eb      Zhyy# e^$ r- ej                  dk\  rd d l
m_Z_ nd d lPm_Z_ e_ZQe_ZSe_ZTe_ZUe_ZVe_ZWd!Z]Y w xY w)3    )annotationsN)ABCabstractmethod)	TYPE_CHECKINGAnyClassVarLiteralNoReturnUnioncastget_args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_key)   
   )	TypeAliasrA   AllowedRSAKeysAllowedECKeysAllowedOKPKeysAllowedKeysAllowedPrivateKeysAllowedPublicKeysSPHINX_BUILD )PrivateKeyTypesPublicKeyTypesT)r?      )NeverF>   ES256ES384ES512ES521EdDSAPS256PS384PS512RS256RS384RS512ES256Kc                 4   t               t        t        j                        t        t        j                        t        t        j                        d} t
        r<| j                  t        t        j                        t        t        j                        t        t        j                        t        t        j                  t              t        t        j                  t              t        t        j                  t              t        t        j                  t              t        t        j                  t              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)rV   rW   rX   rN   rY   rO   rQ   rP   rS   rT   rU   rR   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmr$   r#   r%   r&   RSAPSSAlgorithmOKPAlgorithm)default_algorithmss    L/opt/lhia/marcimex/agent/venv/lib/python3.12/site-packages/jwt/algorithms.pyget_default_algorithmsrl      s	   
 }334}334}334	0 !!%l&9&9:%l&9&9:%l&9&9:$[%7%7C%k&8&8)D$[%7%7C$[%7%7C$&&	 ))?)?@()?)?@()?)?@%	
&     c                     e Zd ZU dZdZded<   ddZddZedd       Z	edd       Z
edd	       Zeeedd
                     Zeee	 d	 	 	 	 	 dd                     Zeeddd              Zeedd              ZddZy)	AlgorithmzH
    The interface for an algorithm used to sign and verify tokens.
    Nz$tuple[type[AllowedKeys], ...] | None_crypto_key_typesc                f   t        | dd      }|t        t        rxt        |t              rht        |t        j                        rNt        j                   |       t                     }|j                  |       t        |j                               S t         ||      j                               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NotImplementedErrorrd   
isinstancetype
issubclassr    HashAlgorithmHashr   re   bytesfinalizedigest)selfbytestrrr   r}   s       rk   compute_hash_digestzAlgorithm.compute_hash_digest   s     4T2%% 8T*8V%9%9:[[_5FGFMM'"*++'*11344rm   c                   t         r| j                  t        d      t        || j                        sSd | j                  D        }|j                  j
                  }| j                  j
                  }t        d| d| d|       y)ac  Check that the key belongs to the right cryptographic family.

        Note that this method only works when ``cryptography`` is installed.

        :param key: Potentially a cryptography key
        :type key: :py:data:`PublicKeyTypes <cryptography.hazmat.primitives.asymmetric.types.PublicKeyTypes>` | :py:data:`PrivateKeyTypes <cryptography.hazmat.primitives.asymmetric.types.PrivateKeyTypes>`
        :raises ValueError: if ``cryptography`` is not installed, or this method is called by a non-cryptography algorithm
        :raises InvalidKeyError: if the key doesn't match the expected key classes
        NzhThis method requires the cryptography library, and should only be used by cryptography-based algorithms.c              3  4   K   | ]  }|j                     y wN)__name__).0clss     rk   	<genexpr>z2Algorithm.check_crypto_key_type.<locals>.<genexpr>   s     LcS\\Ls   zExpected one of z, got: z. Invalid Key type for )rd   rp   
ValueErrorrv   	__class__r   r   )r~   keyvalid_classesactual_class
self_classs        rk   check_crypto_key_typezAlgorithm.check_crypto_key_type   s     T33;z  #t556LT5K5KLM==11L00J!"=/F]^h]ij 	 7rm   c                     y)z
        Performs necessary validation and conversions on the key and returns
        the key value in the proper format for sign() and verify().
        N r~   r   s     rk   prepare_keyzAlgorithm.prepare_key       rm   c                     y)zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nr   r~   msgr   s      rk   signzAlgorithm.sign   r   rm   c                     y)zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nr   r~   r   r   sigs       rk   verifyzAlgorithm.verify   r   rm   c                     y r   r   key_objas_dicts     rk   to_jwkzAlgorithm.to_jwk   s	     BErm   c                     y r   r   r   s     rk   r   zAlgorithm.to_jwk   s    
 rm   c                     y)z3
        Serializes a given key into a JWK
        Nr   r   s     rk   r   zAlgorithm.to_jwk  r   rm   c                     y)zJ
        Deserializes a given key from JWK back into a key object
        Nr   jwks    rk   from_jwkzAlgorithm.from_jwk  r   rm   c                     y)z
        Return a warning message if the key is below the minimum
        recommended length for this algorithm, or None if adequate.
        Nr   r   s     rk   check_key_lengthzAlgorithm.check_key_length  s    
 rm   )r   r{   returnr{   )r   z PublicKeyTypes | PrivateKeyTypesr   None)r   r   r   r   )r   r{   r   r   r   r{   )r   r{   r   r   r   r{   r   bool)r   r   r   Literal[True]r   r   F)r   r   r   Literal[False]r   str)r   r   r   r   r   JWKDict | str)r   str | JWKDictr   r   )r   r   r   
str | None)r   
__module____qualname____doc__rp   __annotations__r   r   r   r   r   r   r   staticmethodr   r   r   r   rm   rk   ro   ro      s    
 ?C;B5,.       D    E05-	      
   
rm   ro   c                  N    e Zd ZdZddZd	dZd
dZeddd       Zedd       Z	y)r_   zZ
    Placeholder for use when no signing or verification
    operations are required.
    c                .    |dk(  rd }|t        d      |S )NrI   z*When alg = "none", key value must be None.r   r   s     rk   r   zNoneAlgorithm.prepare_key   s$    "9C?!"NOO
rm   c                     y)Nrm   r   r   s      rk   r   zNoneAlgorithm.sign)  s    rm   c                     y)NFr   r   s       rk   r   zNoneAlgorithm.verify,  s    rm   c                    t               r   ru   r   s     rk   r   zNoneAlgorithm.to_jwk/      !##rm   c                    t               r   r   r   s    rk   r   zNoneAlgorithm.from_jwk3  r   rm   N)r   r   r   r   )r   r{   r   r   r   r{   )r   r{   r   r   r   r{   r   r   r   )r   r   r   r   r   r
   )r   r   r   r
   )
r   r   r   r   r   r   r   r   r   r   r   rm   rk   r_   r_     s>    
 $ $ $ $rm   r_   c                      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ZddZeedd              Zeeddd	              Zeddd
       Zedd       ZddZddZddZy)r`   zf
    Performs signing and verification operations using HMAC
    and the specified hash function.
    zClassVar[HashlibHash]ra   rb   rc   c                    || _         y r   rr   r~   rr   s     rk   __init__zHMACAlgorithm.__init__B  s	     rm   c                ^    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   )r~   r   	key_bytess      rk   r   zHMACAlgorithm.prepare_keyE  s5    $	#z)'<!9 
 rm   c                     y r   r   r   s     rk   r   zHMACAlgorithm.to_jwkP  s    ILrm   c                     y r   r   r   s     rk   r   zHMACAlgorithm.to_jwkT  s    NQrm   c                ~    t        t        |             j                         dd}|r|S t        j                  |      S )Noct)kkty)r   r   decodejsondumps)r   r   r   s      rk   r   zHMACAlgorithm.to_jwkX  s<     "+g"67>>@

 J::c?"rm   c                   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      t        |d         S # t
        $ r t        d      d w xY w)NKey is not valid JSONr   r   zNot an HMAC keyr   )	rv   r   r   loadsdictr   r   getr   )r   objs     rk   r   zHMACAlgorithm.from_jwkd  s    	E#s##zz#C&   775>U"!"344C))  	E!"9:D	Es   ?A. .Bc                    | j                         j                  }t        |      |k  r;dt        |       d| d| j                         j                  j	                          dS y )NzThe HMAC key is z> bytes long, which is below the minimum recommended length of z bytes for z. See RFC 7518 Section 3.2.)rr   digest_sizelennameupper)r~   r   
min_lengths      rk   r   zHMACAlgorithm.check_key_lengthu  se    ]]_00
s8j "3s8* -55?L==?''--/0 1,- rm   c                `    t        j                  ||| j                        j                         S r   )hmacnewrr   r}   r   s      rk   r   zHMACAlgorithm.sign  s"    xxS$--07799rm   c                N    t        j                  || j                  ||            S r   )r   compare_digestr   r   s       rk   r   zHMACAlgorithm.verify  s     ""3		#s(;<<rm   N)rr   r   r   r   )r   str | bytesr   r{   )r   r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r{   )r   r{   r   r   )r   r{   r   r{   r   r{   )r   r{   r   r{   r   r{   r   r   )r   r   r   r   hashlibsha256ra   r   sha384rb   sha512rc   r   r   r   r   r   r   r   r   r   r   rm   rk   r`   r`   8  s    
 %,NNF!2$+NNF!2$+NNF!2!	 L  LQ  Q	# 	# * * 	:=rm   r`   c                  F   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<    e	e
ee   df    eeeef               ZdZded	<   dd
ZddZddZeedd              Zeeddd              Zeddd       Zedd       ZddZddZy)rf   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]ra   rb   rc   .i   zClassVar[int]_MIN_KEY_SIZEc                    || _         y r   r   r   s     rk   r   zRSAAlgorithm.__init__  s	    $DMrm   c                p    |j                   | j                  k  rd|j                    d| j                   dS y )NzThe RSA key is z; bits long, which is below the minimum recommended size of z bits. See NIST SP 800-131A.)key_sizer   r   s     rk   r   zRSAAlgorithm.check_key_length  sE    ||d000%cll^ 477;7I7I6J K,-
 rm   c                4   t        || j                        rt        t        |      S t        |t        t
        f      st        d      t        |      }	 |j                  d      r,t        |      }| j                  |       t        t        |      S t        |d       }| j                  |       t        t        |      S # t        $ rO 	 t        |      }| j                  |       t        t        |      cY S # t        t         f$ r t#        d      d w xY ww xY w)NExpecting a PEM-formatted key.s   ssh-rsapasswordz(Could not parse the provided public key.)rv   rp   r   rB   r{   r   	TypeErrorr   
startswithr>   r   r2   r<   r0   r   r=   r   r   )r~   r   r   
public_keyprivate_keys        rk   r   zRSAAlgorithm.prepare_key  s   #t556NC00cE3<0 @AA#C(I ''
31DY1OJ..z:j993G!D4K ..{;{;;   !4Y!?J..z:j99"$89  )B   s*   <B? -B? ?	D	+C74D7DDc                     y r   r   r   s     rk   r   zRSAAlgorithm.to_jwk  s    PSrm   c                     y r   r   r   s     rk   r   zRSAAlgorithm.to_jwk  s    UXrm   c                   d }t        | d      r;| j                         }ddgt        |j                  j                        j                         t        |j                  j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         t        |j                        j                         d
}nrt        | d      r[| j                         }ddgt        |j                        j                         t        |j                        j                         d}nt        d      |r|S t        j                  |      S )Nprivate_numbersRSAr   )
r   key_opsnedpqdpdqqir   )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   numberss       rk   r   zRSAAlgorithm.to_jwk  sb   )-Cw 12!113 ! &x*7+A+A+C+CDKKM*7+A+A+C+CDKKM*7995<<>*7995<<>*7995<<>+GLL9@@B+GLL9@@B+GLL9@@B (+!002 ! (z*7995<<>*7995<<>	 &&CDD
zz#&rm   c                :   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d d|v rTd|v rOd|v rJd|v rt        d	      g d
}|D cg c]  }||v  }}t        |      }|rt        |      st        d      d t        t        |d         t        |d               }|rjt        t        |d         t        |d         t        |d         t        |d         t        |d         t        |d         |      }|j'                         S t        |d         }t        |j                  ||j                        \  }	}
t        ||	|
t!        ||	      t#        ||
      t%        |	|
      |      }|j'                         S d|v r6d|v r2t        t        |d         t        |d               j)                         S t        d      # t
        $ r t        d      d w xY wc c}w )Nr   r   r   zNot an RSA keyr   r   r   othz5Unsupported RSA private key: > 2 primes not supported)r   r   r   r   r  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  )rv   r   r   r   r   r   r   r   anyallr3   r   r1   r7   r   r   r4   r5   r6   r   r   )r   r   other_propspropprops_foundany_props_foundr  r  r   r   r   s              rk   r   zRSAAlgorithm.from_jwk  s:   Ic3'**S/CT*C$$ wwu~&%&67TAczcSjSCZC<)O  ;7BCtts{CC"%k"2"3{+;)Z  "2'C1'C1"
 #/-c#h7-c#h7-c#h70T;0T;0T;'5G2 **,, ,CH5A4&((!^-=-=DAq 0)!Q/)!Q/)!Q/'5G **,,s
''C1'C1 *,
 &&CDD{  I%&=>DHI Ds   ?G? H?Hc                l    |j                  |t        j                         | j                               }|S r   )r   r!   PKCS1v15rr   r~   r   r   	signatures       rk   r   zRSAAlgorithm.sign:  s)    "xxW-=-=-?QIrm   c                    	 |j                  ||t        j                         | j                                y# t        $ r Y yw xY w)NTF)r   r!   r  rr   r   r   s       rk   r   zRSAAlgorithm.verify>  s=    

3W%5%5%7I# s   47 	AAN)rr   type[hashes.HashAlgorithm]r   r   )r   rB   r   r   )r   zAllowedRSAKeys | str | bytesr   rB   )r   rB   r   r   r   r   r   )r   rB   r   r   r   r   )r   rB   r   r   r   r   )r   r   r   rB   r   r{   r   r0   r   r{   r   r{   r   r2   r   r{   r   r   )r   r   r   r   r    ra   r   rb   rc   r   tuplerw   rE   r   r   r0   r2   rp   r   r   r   r   r   r   r   r   r   r   r   rm   rk   rf   rf     s    	
 8>}}4D7=}}4D7=}}4D ${#S()U=,678
 (,}+	%		 < 
	S 
 
S		X 
 
X	$	' 
$	'L 
E	E 
E	EN		rm   rf   c                  F   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<    e	e
ee   df    eeeef               Z	 d	 	 	 	 	 ddZdd	Zdd
ZddZddZeedd              Zeeddd              Zeddd       Zedd       Zy)rg   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   ra   rb   rc   .Nc                     || _         || _        y r   )rr   expected_curve)r~   rr   r  s      rk   r   zECAlgorithm.__init__T  s    
 %DM"0Drm   c                    | j                   yt        |j                  | j                         s:t        d|j                  j                   d| j                   j                   d      y)z9Validate that the key's curve matches the expected curve.NzThe key's curve 'z%' does not match the expected curve 'z' for this algorithm)r  rv   curver   r   r   s     rk   _validate_curvezECAlgorithm._validate_curve\  sg    ""*cii)<)<=%'		'7 8"116677KM  >rm   c                &   t        || j                        r#t        t        |      }| j	                  |       |S t        |t
        t        f      st        d      t        |      }	 |j                  d      rt        |      }nt        |      }| j                  |       t        t        |      }| j	                  |       |S # t        $ rD t        |d       }| j                  |       t        t         |      }| j	                  |       |cY S w xY w)Nr   s   ecdsa-sha2-r   )rv   rp   r   rC   r  r{   r   r   r   r   r>   r=   r   r*   r   r<   r(   )r~   r   ec_keyr   r   ec_public_keyr   ec_private_keys           rk   r   zECAlgorithm.prepare_keyg  s    #t556mS1$$V,cE3<0 @AA#C(I
&''71DY1OJ!4Y!?J **:6 $%;Z H$$]3$$ &29tL**;7!%&={!K$$^4%%&s   'AC A
DDc                    |j                  |t        | j                                     }t        ||j                        S r   )r   r"   rr   r   r  )r~   r   r   der_sigs       rk   r   zECAlgorithm.sign  s.    hhsE$--/$:;G';;rm   c                   	 t        ||j                        }	 t        |t              r|j                         n|}|j                  ||t        | j                                      y# t        $ r Y yw xY w# t        $ r Y yw xY w)NFT)
r   r  r   rv   r(   r   r   r"   rr   r   )r~   r   r   r   r%  r   s         rk   r   zECAlgorithm.verify  s    .sCII>	 "#'>? NN$ 
 !!'3dmmo0FG   $ s#   A& AA5 &	A21A25	B Bc                     y r   r   r   s     rk   r   zECAlgorithm.to_jwk  s    ORrm   c                     y r   r   r   s     rk   r   zECAlgorithm.to_jwk  s    TWrm   c                   t        | t              r| j                         j                         }n,t        | t              r| j                         }nt        d      t        | j                  t              rd}not        | j                  t              rd}nRt        | j                  t              rd}n5t        | j                  t              rd}nt        d| j                         d|t        |j                  | j                  j                        j                         t        |j                  | j                  j                        j                         d	}t        | t              rJt        | j!                         j"                  | j                  j                        j                         |d
<   |r|S t%        j&                  |      S )Nr  P-256P-384P-521	secp256k1Invalid curve: EC)
bit_length)r   crvxyr   )rv   r(   r   r  r*   r   r  r$   r%   r&   r#   r   r2  r   r   r3  r   private_valuer   r   )r   r   r  r1  r   s        rk   r   zECAlgorithm.to_jwk  sf   '#:;!(!3!3!5!D!D!FG%;<!(!7!7!9%&CDD'--3GMM95GMM95GMM95!%&GHH &"$$&}}55 &(&"$$&}}55 &(#C '#:;,++-;;&}}55 &( C
 
zz#&rm   c                8   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      d d|vsd|vrt        d      d t        |j                  d            }t        |j                  d            }|j                  d      }|dk(  r7t        |      t        |      cxk(  rd	k(  rn nt               }nt        d
      d |dk(  r7t        |      t        |      cxk(  rdk(  rn nt               }nt        d      d |dk(  r7t        |      t        |      cxk(  rdk(  rn nt               }n_t        d      d |dk(  r@t        |      t        |      cxk(  rd	k(  rn t        d      t               }nt        d      t        d|       t        t        j!                  |d      t        j!                  |d      |      }d|vr|j#                         S t        |j                  d            }t        |      t        |      k7  rt        dt        |      |      t%        t        j!                  |d      |      j'                         S # t
        $ r t        d      d w xY w)Nr   r   r/  zNot an Elliptic curve keyr2  r3  r1  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)r2  r3  r  r   z!D should be {} bytes for curve {})rv   r   r   r   r   r   r   r   r   r   r$   r%   r&   r#   r+   int
from_bytesr   r)   r   )r   r   r2  r3  r  	curve_objr  r   s           rk   r   zECAlgorithm.from_jwk  sr   Ic3'**S/CT*C$$ wwu~%%&ABL#~C%&ABL .A .AGGENE q6SV)r) )I)C  '!q6SV)r) )I)C  '!q6SV)r) )I)C  +%q6SV)r) *G  !*I)G  &w&?@@7..e.4..e.4N #~%0022 .A1vQ%7Q  /qE2Nkm{  I%&=>DHIs   ?J Jr   )rr   r  r  ztype[EllipticCurve] | Noner   r   )r   rC   r   r   )r   zAllowedECKeys | str | bytesr   rC   )r   r{   r   r(   r   r{   )r   r{   r   rC   r   r{   r   r   )r   rC   r   r   r   r   r   )r   rC   r   r   r   r   )r   rC   r   r   r   r   )r   r   r   rC   )r   r   r   r   r    ra   r   rb   rc   r   r  rw   rE   r   r   r(   r*   rp   r   r  r   r   r   r   r   r   r   r   rm   rk   rg   rg   E  s    	
 8>}}4D7=}}4D7=}}4D ${#S()U24JJKL
 :>	10	1 7	1 		1			&@	<
	" 
	R 
 
R		W 
 
W	)	' 
)	'V 
G	 
G	rm   rg   c                       e Zd ZdZddZddZy)rh   zA
        Performs a signature using RSASSA-PSS with MGF1
        c           	         |j                  |t        j                  t        j                  | j	                               | j	                         j
                        | j	                               }|S )Nmgfsalt_length)r   r!   PSSMGF1rr   r   r  s       rk   r   zRSAPSSAlgorithm.sign   sS    "xxT]]_5 $ ; ;  I rm   c           
        	 |j                  ||t        j                  t        j                  | j	                               | j	                         j
                        | j	                                y# t        $ r Y yw xY w)Nr@  TF)r   r!   rC  rD  rr   r   r   r   s       rk   r   zRSAPSSAlgorithm.verify+  sh    

KK#LL9$(MMO$?$? MMO # s   A0A3 3	A?>A?Nr  r  )r   r   r   r   r   r   r   rm   rk   rh   rh     s    				rm   rh   c            
          e Zd ZdZ eeee   df    ee	e
eeef               ZddZddZ	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZeedd              Zeeddd              Zeddd	       Zedd
       Zy)ri   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        .c                     y r   r   )r~   kwargss     rk   r   zOKPAlgorithm.__init__M  s    rm   c                   t        |t        t        f      s| j                  |       |S t        |t              r|j	                  d      n|}t        |t              r|j                  d      n|}d|v rt        |      }n1d|v rt        |d       }n|dd dk(  rt        |      }nt        d      | j                  |       t        d	|      S )
Nutf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr   r      zssh-r  rD   )rv   r   r{   r   r   encoder=   r<   r>   r   r   )r~   r   key_strr   
loaded_keys        rk   r   zOKPAlgorithm.prepare_keyP  s    cC<0**3/
-7U-Ccjj)G/9#s/C

7+I #g-0;
%01)dK
1'0;
%&CDD &&z2(*55rm   c                n    t        |t              r|j                  d      n|}|j                  |      }|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
            rJ  )rv   r   rL  r   )r~   r   r   	msg_bytesr  s        rk   r   zOKPAlgorithm.signf  s1     0:#s/C

7+I"xx	2Irm   c                $   	 t        |t              r|j                  d      n|}t        |t              r|j                  d      n|}t        |t        t        f      r|j                         n|}|j                  ||       y# t        $ r Y yw xY 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.
            rJ  TF)rv   r   rL  r.   r,   r   r   r   )r~   r   r   r   rP  	sig_bytesr   s          rk   r   zOKPAlgorithm.verifyt  s    3=c33GCJJw/S	3=c33GCJJw/S	 "#(9?'KL NN$ 
 !!)Y7# s   B B 	BBc                     y r   r   r   r   s     rk   r   zOKPAlgorithm.to_jwk  s    LOrm   c                     y r   r   rT  s     rk   r   zOKPAlgorithm.to_jwk  s    QTrm   c                F   t        | t        t        f      r| j                  t        j
                  t        j
                        }t        | t              rdnd}t        t        |            j                         d|d}|r|S t        j                  |      S t        | t        t        f      r| j                  t        j
                  t        j
                  t!                     }| j#                         j                  t        j
                  t        j
                        }t        | t              rdnd}t        t        |            j                         t        t        |            j                         d|d}|r|S t        j                  |      S t%        d      )	N)encodingformatEd25519Ed448OKP)r2  r   r1  )rW  rX  encryption_algorithm)r2  r   r   r1  r  )rv   r/   r-   public_bytesr8   Rawr;   r   r   r   r   r   r.   r,   private_bytesr:   r9   r   r   )r   r   r2  r1  r   r   s         rk   r   zOKPAlgorithm.to_jwk  s\   # 0.AB$$%\\'++ %  $.c3C#Di' *+a.9@@B  J::c?*# 1?CD%%%\\(,,)5 &  NN$11%\\'++ 2 
 $.c3D#Ei7)+a.9@@B)+a.9@@B 	 J::c?*!"?@@rm   c                   	 t        | t              rt        j                  |       }nt        | t              r| }nt
        |j                  d      dk7  rt        d      |j                  d      }|dk7  r|dk7  rt        d|       d	|vrt        d
      t        |j                  d	            }	 d|vr/|dk(  rt        j                  |      S t        j                  |      S t        |j                  d            }|dk(  rt        j                  |      S t        j                  |      S # t
        $ r t        d      d w xY w# t
        $ r}t        d      |d }~ww xY w)Nr   r   r[  zNot an Octet Key Pairr1  rY  rZ  r.  r2  zOKP should have "x" parameterr   zInvalid key parameter)rv   r   r   r   r   r   r   r   r   r/   from_public_bytesr-   r.   from_private_bytesr,   )r   r   r  r2  r   errs         rk   r   zOKPAlgorithm.from_jwk  sZ   Ic3'**S/CT*C$$ wwu~&%&=>>GGENE	!ew&6%w&?@@#~%&EFF .A
Hc>	)/AA!DD);;A>>$SWWS\2I%,??BB&99!<<-  I%&=>DHI.  H%&=>CGHs5   ?D/ 3E E &3E E /E	E"EE"N)rH  r   r   r   )r   zAllowedOKPKeys | str | bytesr   rD   )r   r   r   z#Ed25519PrivateKey | Ed448PrivateKeyr   r{   )r   r   r   rD   r   r   r   r   )r   rD   r   r   r   r   r   )r   rD   r   r   r   r   )r   rD   r   r   r   r   )r   r   r   rD   )r   r   r   r   r   r  rw   rE   r   r   r.   r/   r,   r-   rp   r   r   r   r   r   r   r   r   r   rm   rk   ri   ri   :  s    	 !${#S()%$#"$

		6,	"	)L			"	)7	>I		4 
	O 
 
O		T 
 
T	,	A 
,	A\ 
 	H 
 	Hrm   ri   )r   zdict[str, Algorithm])i
__future__r   r   r   r   ossysabcr   r   typingr   r   r   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.rsar0   r1   r2   r3   r4   r5   r6   r7   ,cryptography.hazmat.primitives.serializationr8   r9   r:   r;   r<   r=   r>   version_inforA   typing_extensionsrB   r   rC   rD   rE   rF   rG   r   getenv/cryptography.hazmat.primitives.asymmetric.typesrJ   rK   rd   ModuleNotFoundErrorrM   requires_cryptographyrl   ro   r_   r`   rf   rg   rh   ri   r   rm   rk   <module>r{     s2   "    	 
 #
 
 
 ( '
 
 
VN<5A  	 	 	   7"$ 	0 !&m\&A BNIB$%<>T%TUM9U %+_nL!NI  #>=.#PQKQ$).0A?R%	  $),.>N$y  YRYY~r:;	

 J   Di iX$I $<L=I L=^ zy zxTi Tl, >lHy lHg u  
7" +NMNKJs   C8F0 0/G"!G"