
    qib                       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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 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-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZC d dlDmEZEmFZFmGZGmHZHmIZImJZJmKZK e<e>fZLe1e3fZMe9e:e6e7fZNeLeMz   eNz   ZOe<e1e9e6fZPe>e3e:e7fZQe
s eR ej                  dd            rwd dlTZTeTj                  dk\  rd dl	mVZV nd dlWmVZV d dlXmYZYmZZZ ee<e>f   Z[de\d<   ee1e3f   Z]de\d<   ee9e:e6e7f   Z^de\d<   ee[e]e^f   Z_de\d<   ee<e1e9e6f   Z`de\d<   ee>e3e:e7f   Zade\d<   dZbh d Zdd0d!Ze G d" d#e      Zf G d$ d%ef      Zg G d& d'ef      Zhebr- G d( d)ef      Zi G d* d+ef      Zj G d, d-ei      Zk G d. d/ef      Zlyy# ec$ r dZbY bw xY w)1    )annotationsN)ABCabstractmethod)TYPE_CHECKINGAnyClassVarLiteralNoReturnUnioncastoverload   InvalidKeyError)HashlibHashJWKDict)	base64url_decodebase64url_encodeder_to_raw_signatureforce_bytesfrom_base64url_uintis_pem_format
is_ssh_keyraw_to_der_signatureto_base64url_uint)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SPHINX_BUILD )   
   )	TypeAlias)PrivateKeyTypesPublicKeyTypesrB   AllowedRSAKeysAllowedECKeysAllowedOKPKeysAllowedKeysAllowedPrivateKeysAllowedPublicKeysTF>   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)rS   rT   rU   rK   rV   rL   rN   rM   rP   rQ   rR   rO   )NoneAlgorithmHMACAlgorithmSHA256SHA384SHA512
has_cryptoupdateRSAAlgorithmECAlgorithmr#   r"   r$   r%   RSAPSSAlgorithmOKPAlgorithm)default_algorithmss    @/opt/pipecat/venv/lib/python3.12/site-packages/jwt/algorithms.pyget_default_algorithmsri      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NotImplementedErrorra   
isinstancetype
issubclassr   HashAlgorithmHashr   rb   bytesfinalizedigest)selfbytestrro   rz   s       rh   compute_hash_digestzAlgorithm.compute_hash_digest   s     4T2%% 8T*8V%9%9:[[_5FGFMM'"*++'*11344rj   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     rh   	<genexpr>z2Algorithm.check_crypto_key_type.<locals>.<genexpr>   s     LcS\\Ls   zExpected one of z, got: z. Invalid Key type for )ra   rm   
ValueErrorrs   	__class__r   r   )r{   keyvalid_classesactual_class
self_classs        rh   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 	 7rj   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     rh   prepare_keyzAlgorithm.prepare_key       rj   c                     y)zn
        Returns a digital signature for the specified message
        using the specified key value.
        Nr   r{   msgr   s      rh   signzAlgorithm.sign   r   rj   c                     y)zz
        Verifies that the specified digital signature is valid
        for the specified message and key values.
        Nr   r{   r   r   sigs       rh   verifyzAlgorithm.verify  r   rj   c                     y r   r   key_objas_dicts     rh   to_jwkzAlgorithm.to_jwk	  s	     BErj   c                     y r   r   r   s     rh   r   zAlgorithm.to_jwk  s    
 rj   c                     y)z3
        Serializes a given key into a JWK
        Nr   r   s     rh   r   zAlgorithm.to_jwk  r   rj   c                     y)zJ
        Deserializes a given key from JWK back into a key object
        Nr   jwks    rh   from_jwkzAlgorithm.from_jwk  r   rj   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     rh   check_key_lengthzAlgorithm.check_key_length#  s    
 rj   )r|   rx   returnrx   )r   z PublicKeyTypes | PrivateKeyTypesr   None)r   r   r   r   )r   rx   r   r   r   rx   )r   rx   r   r   r   rx   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__rm   __annotations__r}   r   r   r   r   r   r   staticmethodr   r   r   r   rj   rh   rl   rl      s    
 ?C;B5,.       D    E05-	      
   
rj   rl   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 )Nr?   z*When alg = "none", key value must be None.r   r   s     rh   r   zNoneAlgorithm.prepare_key1  s$    "9C?!"NOO
rj   c                     y)Nrj   r   r   s      rh   r   zNoneAlgorithm.sign:  s    rj   c                     y)NFr   r   s       rh   r   zNoneAlgorithm.verify=  s    rj   c                    t               r   rr   r   s     rh   r   zNoneAlgorithm.to_jwk@      !##rj   c                    t               r   r   r   s    rh   r   zNoneAlgorithm.from_jwkD  r   rj   N)r   r   r   r   )r   rx   r   r   r   rx   )r   rx   r   r   r   rx   r   r   r   )r   r   r   r   r   r
   )r   r   r   r
   )
r   r   r   r   r   r   r   r   r   r   r   rj   rh   r\   r\   +  s>    
 $ $ $ $rj   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]r^   r_   r`   c                    || _         y r   ro   r{   ro   s     rh   __init__zHMACAlgorithm.__init__S  s	     rj   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      rh   r   zHMACAlgorithm.prepare_keyV  s5    $	#z)'<!9 
 rj   c                     y r   r   r   s     rh   r   zHMACAlgorithm.to_jwka  s    ILrj   c                     y r   r   r   s     rh   r   zHMACAlgorithm.to_jwke  s    NQrj   c                ~    t        t        |             j                         dd}|r|S t        j                  |      S )Noct)kkty)r   r   decodejsondumps)r   r   r   s      rh   r   zHMACAlgorithm.to_jwki  s<     "+g"67>>@

 J::c?"rj   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   )	rs   r   r   loadsdictr   r   getr   )r   objs     rh   r   zHMACAlgorithm.from_jwku  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.)ro   digest_sizelennameupper)r{   r   
min_lengths      rh   r   zHMACAlgorithm.check_key_length  se    ]]_00
s8j "3s8* -55?L==?''--/0 1,- rj   c                `    t        j                  ||| j                        j                         S r   )hmacnewro   rz   r   s      rh   r   zHMACAlgorithm.sign  s"    xxS$--07799rj   c                N    t        j                  || j                  ||            S r   )r   compare_digestr   r   s       rh   r   zHMACAlgorithm.verify  s     ""3		#s(;<<rj   N)ro   r   r   r   )r   str | bytesr   rx   )r   r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   r   r   )r   r   r   rx   )r   rx   r   r   )r   rx   r   rx   r   rx   )r   rx   r   rx   r   rx   r   r   )r   r   r   r   hashlibsha256r^   r   sha384r_   sha512r`   r   r   r   r   r   r   r   r   r   r   rj   rh   r]   r]   I  s    
 %,NNF!2$+NNF!2$+NNF!2!	 L  LQ  Q	# 	# * * 	:=rj   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<   e	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)rc   z~
        Performs signing and verification operations using
        RSASSA-PKCS-v1_5 and the specified hash function.
        $ClassVar[type[hashes.HashAlgorithm]]r^   r_   r`   i   zClassVar[int]_MIN_KEY_SIZEc                    || _         y r   r   r   s     rh   r   zRSAAlgorithm.__init__  s	    $DMrj   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     rh   r   zRSAAlgorithm.check_key_length  sE    ||d000%cll^ 477;7I7I6J K,-
 rj   c                   t        || j                        r|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.)rs   rm   rx   r   	TypeErrorr   
startswithr=   r   r   r1   r;   r/   r   r<   r   r   )r{   r   r   
public_keyprivate_keys        rh   r   zRSAAlgorithm.prepare_key  s    #t556
cE3<0 @AA#C(I ''
31DY1OJ..z:j993G!D4K ..{;{;;   !4Y!?J..z:j99"$89  )B   s*   <B1 -B1 1	D	;+C)&D	)DD	c                     y r   r   r   s     rh   r   zRSAAlgorithm.to_jwk  s    PSrj   c                     y r   r   r   s     rh   r   zRSAAlgorithm.to_jwk  s    UXrj   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       rh   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#&rj   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   )rs   r   r   r   r   r   r   r   anyallr2   r   r0   r6   r   r   r3   r4   r5   r   r   )r   r   other_propspropprops_foundany_props_foundr  r  r   r   r   s              rh   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    PKCS1v15ro   r{   r   r   	signatures       rh   r   zRSAAlgorithm.signH  s)    "xxW-=-=-?QIrj   c                    	 |j                  ||t        j                         | j                                y# t        $ r Y yw xY w)NTF)r   r    r  ro   r   r   s       rh   r   zRSAAlgorithm.verifyL  s=    

3W%5%5%7I# s   47 	AAN)ro   type[hashes.HashAlgorithm]r   r   )r   rE   r   r   )r   zAllowedRSAKeys | str | bytesr   rE   )r   rE   r   r   r   r   r   )r   rE   r   r   r   r   )r   rE   r   r   r   r   )r   r   r   rE   r   rx   r   r/   r   rx   r   rx   r   r1   r   rx   r   r   )r   r   r   r   r   r^   r   r_   r`   ALLOWED_RSA_KEY_TYPESrm   r   r   r   r   r   r   r   r   r   r   r   rj   rh   rc   rc     s    	
 8>}}4D7=}}4D7=}}4D1'+}+	%		 < 
	S 
 
S		X 
 
X	$	' 
$	'L 
E	E 
E	EN		rj   rc   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<   e	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)rd   zr
        Performs signing and verification operations using
        ECDSA and the specified hash function
        r   r^   r_   r`   Nc                     || _         || _        y r   )ro   expected_curve)r{   ro   r  s      rh   r   zECAlgorithm.__init___  s    
 %DM"0Drj   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  rs   curver   r   r   s     rh   _validate_curvezECAlgorithm._validate_curveg  sg    ""*cii)<)<=%'		'7 8"116677KM  >rj   c                   t        || j                        r| 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   )rs   rm   r  rx   r   r   r   r   r=   r<   r   r   r)   r   r;   r'   )r{   r   r   r   ec_public_keyr   ec_private_keys          rh   r   zECAlgorithm.prepare_keyr  s    #t556$$S)
cE3<0 @AA#C(I
&''71DY1OJ!4Y!?J **:6 $%;Z H$$]3$$ &29tL**;7!%&={!K$$^4%%&s   AB3 3A
D ?D c                    |j                  |t        | j                                     }t        ||j                        S r   )r   r!   ro   r   r  )r{   r   r   der_sigs       rh   r   zECAlgorithm.sign  s.    hhsE$--/$:;G';;rj   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   rs   r'   r   r   r!   ro   r   )r{   r   r   r   r!  r   s         rh   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     rh   r   zECAlgorithm.to_jwk  s    ORrj   c                     y r   r   r   s     rh   r   zECAlgorithm.to_jwk  s    TWrj   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   )rs   r'   r   r  r)   r   r  r#   r$   r%   r"   r   r.  r   r   r/  r   private_valuer   r   )r   r   r  r-  r   s        rh   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#&rj   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 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 {})rs   r   r   r   r   r   r   r   r   r   r#   r$   r%   r"   r*   int
from_bytesr   r(   r   )r   r   r.  r/  r  	curve_objr  r   s           rh   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   )ro   r  r  ztype[EllipticCurve] | Noner   r   )r   rF   r   r   )r   zAllowedECKeys | str | bytesr   rF   )r   rx   r   r'   r   rx   )r   rx   r   rF   r   rx   r   r   )r   rF   r   r   r   r   r   )r   rF   r   r   r   r   )r   rF   r   r   r   r   )r   r   r   rF   )r   r   r   r   r   r^   r   r_   r`   ALLOWED_EC_KEY_TYPESrm   r   r  r   r   r   r   r   r   r   r   rj   rh   rd   rd   S  s    	
 8>}}4D7=}}4D7=}}4D0
 :>	10	1 7	1 		1			&>	<
	" 
	R 
 
R		W 
 
W	)	' 
)	'V 
G	 
G	rj   rd   c                       e Zd ZdZddZddZy)re   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MGF1ro   r   r  s       rh   r   zRSAPSSAlgorithm.sign*  sS    "xxT]]_5 $ ; ;  I rj   c           
        	 |j                  ||t        j                  t        j                  | j	                               | j	                         j
                        | j	                                y# t        $ r Y yw xY w)Nr=  TF)r   r    r@  rA  ro   r   r   r   s       rh   r   zRSAPSSAlgorithm.verify5  sh    

KK#LL9$(MMO$?$? MMO # s   A0A3 3	A?>A?Nr  r  )r   r   r   r   r   r   r   rj   rh   re   re   %  s    				rj   re   c                      e Zd ZdZe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
)rf   z
        Performs signing and verification operations using EdDSA

        This class requires ``cryptography>=2.6`` to be installed.
        c                     y r   r   )r{   kwargss     rh   r   zOKPAlgorithm.__init__M  s    rj   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   rG   )rs   r   rx   r   r   encoder<   r;   r=   r   r   )r{   r   key_strr   
loaded_keys        rh   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5rj   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
            rG  )rs   r   rI  r   )r{   r   r   	msg_bytesr  s        rh   r   zOKPAlgorithm.signf  s1     0:#s/C

7+I"xx	2Irj   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.
            rG  TF)rs   r   rI  r-   r+   r   r   r   )r{   r   r   r   rM  	sig_bytesr   s          rh   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     rh   r   zOKPAlgorithm.to_jwk  s    LOrj   c                     y r   r   rQ  s     rh   r   zOKPAlgorithm.to_jwk  s    QTrj   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)r.  r   r-  )rT  rU  encryption_algorithm)r.  r   r   r-  r   )rs   r.   r,   public_bytesr7   Rawr:   r   r   r   r   r   r-   r+   private_bytesr9   r8   r   r   )r   r   r.  r-  r   r   s         rh   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?*!"?@@rj   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   rX  zNot an Octet Key Pairr-  rV  rW  r*  r.  zOKP should have "x" parameterr   zInvalid key parameter)rs   r   r   r   r   r   r   r   r   r.   from_public_bytesr,   r-   from_private_bytesr+   )r   r   r  r.  r   errs         rh   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)rE  r   r   r   )r   zAllowedOKPKeys | str | bytesr   rG   )r   r   r   z#Ed25519PrivateKey | Ed448PrivateKeyr   rx   )r   r   r   rG   r   r   r   r   )r   rG   r   r   r   r   r   )r   rG   r   r   r   r   )r   rG   r   r   r   r   )r   r   r   rG   )r   r   r   r   ALLOWED_OKP_KEY_TYPESrm   r   r   r   r   r   r   r   r   r   rj   rh   rf   rf   D  s    	 2		6,	"	)L			"	)7	>I		4 
	O 
 
O		T 
 
T	,	A 
,	A\ 
 	H 
 	Hrj   rf   )r   zdict[str, Algorithm])m
__future__r   r   r   r   osabcr   r   typingr   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.rsar/   r0   r1   r2   r3   r4   r5   r6   ,cryptography.hazmat.primitives.serializationr7   r8   r9   r:   r;   r<   r=   r  r:  ra  ALLOWED_KEY_TYPESALLOWED_PRIVATE_KEY_TYPESALLOWED_PUBLIC_KEY_TYPESr   getenvsysversion_inforB   typing_extensions/cryptography.hazmat.primitives.asymmetric.typesrC   rD   rE   r   rF   rG   rH   rI   rJ   ra   ModuleNotFoundErrorrequires_cryptographyri   rl   r\   r]   rc   rd   re   rf   r   rj   rh   <module>r|     sq   "    	 #	 	 	 ( '
 
 
iN<5A  	 	 	   +L935KL	 	 447LL  		! 		  YRYY~r:;w&( 4	
 %*-*E$F	F#(#%;;$
y 	
 %*/.P%
	 	
 "'~}n'T!UYU(-24EV)
I 	
 (-02BNR(
9 	
 J
  Di iX$I $<L=I L=^ wy wrPi Pd, >bHy bHY _  Js   DG GG