__  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

[email protected]: ~ $
�

�?}g�v����SSKJr SSKrSSKrSSKrSSKJrJr SSKJ	r	J
r
JrJrJ
r
JrJr SSKJr SSKJrJr SSKJrJrJrJrJrJrJrJrJr SS	KJ r J!r! SS
K"J#r# SSK$J%r% SSK&J'r' SS
K(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2 SSK3J4r4J5r5 SSK6J7r7J8r8 SSK9J:r:J;r;J<r<J=r=J>r>J?r?J@r@JArA SSKBJCrCJDrDJErEJFrFJGrGJHrHJIrI SrJ\	(a3\:\<-rL\/\1-rM\7\8-\4-\5-rN\L\M-\N-rO\:\/-\7-\4-rP\<\1-\8-\5-rQ1SkrRS$SjrS"SS\5rT"SS\T5rU"SS\T5rV\J(a-"SS\T5rW"SS\T5rX"S S!\W5rY"S"S#\T5rZgg!\Ka SrJN�f=f)%�)�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�ES256Kc��[5[[R5[[R5[[R5S.n[
(Ga#UR
[[R5[[R5[[R5[[R5[[R5[[R5[[R5[[R5[[R5[[R5[[R5[5S.5 U$)z=
Returns the algorithms that are implemented by the library.
)�none�HS256�HS384�HS512)rErFrGr=rHr>r@r?rBrCrDrA)�
NoneAlgorithm�
HMACAlgorithm�SHA256�SHA384�SHA512�
has_crypto�update�RSAAlgorithm�ECAlgorithm�RSAPSSAlgorithm�OKPAlgorithm)�default_algorithmss �0/usr/lib/python3/dist-packages/jwt/algorithms.py�get_default_algorithmsr[is��
���}�3�3�4��}�3�3�4��}�3�3�4�	���z��!�!�%�l�&9�&9�:�%�l�&9�&9�:�%�l�&9�&9�:�$�[�%7�%7�8�%�k�&8�&8�9�$�[�%7�%7�8�$�[�%7�%7�8�$��&�&��)��)?�)?�@�(��)?�)?�@�(��)?�)?�@�%��
�	
�&��c���\rSrSrSrS
Sjr\SSj5r\SSj5r\SSj5r	\
\\SSj555r\
\\SSSjj555r\\SSS	jj55r\\SS
j55r
Srg)�	Algorithm�z@
The interface for an algorithm used to sign and verify tokens.
c��[USS5nUc[e[(a�[U[5(ak[U[R5(aL[R"U"5[5S9nURU5 [UR55$[U"U5R55$)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�HashrrT�bytes�finalize�digest)�self�bytestrrarls    rZ�compute_hash_digest�Algorithm.compute_hash_digest�s����4��T�2����%�%�
�J��8�T�*�*��8�V�%9�%9�:�:��[�[���_�5F�G�F��M�M�'�"�����*�+�+���'�*�1�1�3�4�4r\c��g)z�
Performs necessary validation and conversions on the key and returns
the key value in the proper format for sign() and verify().
N��rm�keys  rZ�prepare_key�Algorithm.prepare_key���r\c��g)zV
Returns a digital signature for the specified message
using the specified key value.
Nrr�rm�msgrts   rZ�sign�Algorithm.sign�rwr\c��g)zb
Verifies that the specified digital signature is valid
for the specified message and key values.
Nrr�rmrzrt�sigs    rZ�verify�Algorithm.verify�rwr\c��g�Nrr��key_obj�as_dicts  rZ�to_jwk�Algorithm.to_jwk�s��=@r\c��gr�rrr�s  rZr�r��s	��BEr\c��g)z#
Serializes a given key into a JWK
Nrrr�s  rZr�r��rwr\c��g)z:
Deserializes a given key from JWK back into a key object
Nrr��jwks rZ�from_jwk�Algorithm.from_jwk�rwr\rrN)rnrj�returnrj)rtrr�r)rzrjrtrr�rj)rzrjrtrrrjr��bool)r��
Literal[True]r�r�F)r��Literal[False]r��str)r�r�r��
JWKDict | str)r��
str | JWKDictr�r)�__name__�
__module__�__qualname__�__firstlineno__�__doc__rorrur{r�r�staticmethodr�r��__static_attributes__rrr\rZr^r^�s����5�,���������������?����@�
���D����E�������
�����r\r^c�b�\rSrSrSrS
SjrSSjrSSjr\S
SSjj5r	\SSj5r
Srg	)rN��zN
Placeholder for use when no signing or verification
operations are required.
c�2�US:XaSnUb[S5eU$)N�z*When alg = "none", key value must be None.rrss  rZru�NoneAlgorithm.prepare_key�s$���"�9��C��?�!�"N�O�O��
r\c��g)Nr\rrrys   rZr{�NoneAlgorithm.sign�s��r\c��g)NFrrr~s    rZr��NoneAlgorithm.verify�s��r\c��[5er��rdr�s  rZr��NoneAlgorithm.to_jwk����!�#�#r\c��[5er�r�r�s rZr��NoneAlgorithm.from_jwk�r�r\rrN)rtz
str | Noner��None)rzrjrtr�r�rj)rzrjrtr�rrjr�r�r�)r�rr�r�r�r
)r�r�r�r
)r�r�r�r�r�rur{r�r�r�r�r�rrr\rZrNrN�s>���
����$��$��$��$r\rNc�,�\rSrSr%Sr\RrS\S'\Rr
S\S'\RrS\S'SSjr
SSjr\\SS	j55r\\SSS
jj55r\SSSjj5r\SSj5rSS
jrSSjrSrg)rO��zZ
Performs signing and verification operations using HMAC
and the specified hash function.
zClassVar[HashlibHash]rPrQrRc��Xlgr��ra�rmras  rZ�__init__�HMACAlgorithm.__init__�s�� �
r\c�r�[U5n[U5(d[U5(a[S5eU$)NzdThe specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.)rrrr�rmrt�	key_bytess   rZru�HMACAlgorithm.prepare_key�s;����$�	���#�#�z�)�'<�'<�!�9��
�
�r\c��gr�rrr�s  rZr��HMACAlgorithm.to_jwk
���r\c��gr�rrr�s  rZr�r�s��r\c��[[U55R5SS.nU(aU$[R"U5$)N�oct)�k�kty)rr�decode�json�dumps)r�r�r�s   rZr�r�s<��"�+�g�"6�7�>�>�@��
��
��J��:�:�c�?�"r\c�(�[U[5(a[R"U5nO[U[5(aUnO[
eURS5S:wa[
S5e[US5$![
a
 [
S5Sef=f)N�Key is not valid JSONr�r�zNot an HMAC keyr�)	rer�r��loads�dict�
ValueErrorr�getr)r��objs  rZr��HMACAlgorithm.from_jwk"s���	E��#�s�#�#�#�z�z�#����C��&�&��� � ��7�7�5�>�U�"�!�"3�4�4���C��)�)��
�	E�!�"9�:��D�	E�s�+A:�A:�A:�:Bc�`�[R"X!UR5R5$r�)�hmac�newrarlrys   rZr{�HMACAlgorithm.sign3s ���x�x��$�-�-�0�7�7�9�9r\c�L�[R"X0RX55$r�)r��compare_digestr{r~s    rZr��HMACAlgorithm.verify6s���"�"�3�	�	�#�(;�<�<r\r�N)rarr�r�)rt�str | bytesr�rj)r�r�r�r�r�rr�)r�r�r�r�r�r�)r�r�r�r�r�r�)r�r�r�rj)rzrjrtrjr�rj)rzrjrtrjrrjr�r�)r�r�r�r�r��hashlib�sha256rP�__annotations__�sha384rQ�sha512rRr�rurr�r�r�r{r�r�rrr\rZrOrO�s����
%,�N�N�F�!�2�$+�N�N�F�!�2�$+�N�N�F�!�2�!�	������'4��	�������8=����'5��	������	#��	#��*��*� :�=r\rOc�,�\rSrSr%Sr\RrS\S'\RrS\S'\Rr	S\S'SSjr
SSjr\\
SS	j55r\\
SSS
jj55r\
SSSjj5r\
SSj5rSS
jrSSjrSrg)rUi<zf
Performs signing and verification operations using
RSASSA-PKCS-v1_5 and the specified hash function.
�$ClassVar[type[hashes.HashAlgorithm]]rPrQrRc��Xlgr�r�r�s  rZr��RSAAlgorithm.__init__F���$�Mr\c���[U[[45(aU$[U[[45(d[S5e[
U5nURS5(a[[[U55$[[[USS95$![a= [[[U55s$![[4a
 [S5Sef=ff=f)N�Expecting a PEM-formatted key.sssh-rsa��passwordz(Could not parse the provided public key.)rer.r0rjr��	TypeErrorr�
startswithrr<r:r�r;rrr�s   rZru�RSAAlgorithm.prepare_keyIs����#�
�|�<�=�=��
��c�E�3�<�0�0�� @�A�A�#�C�(�I�

 ��'�'�
�3�3���.A�)�.L�M�M��%�';�I�PT�'U�����
 � ���.A�)�.L�M�M��"�$8�9� �)�B��� � ��
 �s*�.B�?B�
C�"B=�:C�=C�Cc��gr�rrr�s  rZr��RSAAlgorithm.to_jwka���r\c��gr�rrr�s  rZr�r�gr�r\c���Sn[US5(Ga;UR5nSS/[URR5R5[URR5R5[UR5R5[UR5R5[UR5R5[UR5R5[UR5R5[UR5R5S.
nOw[US5(a[UR5nSS/[UR5R5[UR5R5S.nO[S5eU(aU$[R"U5$)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�iqmprr�r�)r�r�r��numberss    rZr�r�msh��)-�C��w� 1�2�2�!�1�1�3��!� &�x�*�7�+A�+A�+C�+C�D�K�K�M�*�7�+A�+A�+C�+C�D�K�K�M�*�7�9�9�5�<�<�>�*�7�9�9�5�<�<�>�*�7�9�9�5�<�<�>�+�G�L�L�9�@�@�B�+�G�L�L�9�@�@�B�+�G�L�L�9�@�@�B�����(�+�+�!�0�0�2��!� (�z�*�7�9�9�5�<�<�>�*�7�9�9�5�<�<�>�	��&�&C�D�D���
��z�z�#��&r\c�z�[U[5(a[R"U5nO[U[5(aUnO[
eURS5S:wa[
S5SeSU;GaaSU;GaZSU;GaSSU;a[
S	5e/S
QnUVs/sHo3U;PM	 nn[U5nU(a[U5(d[
S5Se[[US5[US55nU(ag[[US5[US5[US
5[US5[US5[US5US9nUR'5$[US5n[URX�R5up�[UU	U
[!X�5[#X�5[%X�5US9nUR'5$SU;a8SU;a2[[US5[US55R)5$[
S5e![
a
 [
S5Sef=fs snf)Nr�r�r�zNot 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�)rer�r�r�r�r�rr��any�allr1rr/r5r�r�r2r3r4�private_key�
public_key)r�r��other_props�prop�props_found�any_props_foundr�r�r�r�r�s           rZr��RSAAlgorithm.from_jwk�s8��
I��c�3�'�'��*�*�S�/�C���T�*�*��C�$�$��w�w�u�~��&�%�&6�7�T�A��c�z�c�S�j�S�C�Z��C�<�)�O���;��7B�C�{�t�s�{�{��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��G�2�*�*�,�,�,�C��H�5�A�4�&�(�(�!�-=�-=��D�A�0����)�!�/�)�!�/�)�!�/�'5��G��*�*�,�,�����s�
�'�'��C��1�'��C��1���*�,��
&�&C�D�D��{�
I�%�&=�>�D�H�
I��Ds�+H�H�H�H8�H5c�j�URU[R"5UR55$r�)r{r�PKCS1v15rarys   rZr{�RSAAlgorithm.sign�s$���8�8�C��!1�!1�!3�T�]�]�_�E�Er\c��URX1[R"5UR55 g![a gf=f)NTF)r�rr	rarr~s    rZr��RSAAlgorithm.verify�s;��
��
�
�3�W�%5�%5�%7�����I���#�
��
�s�47�
A�Ar�N�raztype[hashes.HashAlgorithm]r�r�)rtzAllowedRSAKeys | str | bytesr��AllowedRSAKeys)r�rr�r�r�rr�)r�rr�r�r�r�)r�rr�r�r�r�)r�r�r�r�rzrjrtr.r�rj�rzrjrtr0rrjr�r�)r�r�r�r�r�rrPr�rQrRr�rurr�r�r�r{r�r�rrr\rZrUrU<s���	�
8>�}�}��4�D�7=�}�}��4�D�7=�}�}��4�D�	%�	 �0
�	�	�#�	�.;�	�
�	�
�
�	�
�	�?D�	�#�	�.<�	�
�	�
�
�	�
�$	'�
�$	'�L
�E	E�
�E	E�N	F�	r\rUc�,�\rSrSr%Sr\RrS\S'\RrS\S'\Rr	S\S'SSjr
SSjrSS	jrSS
jr
\\SSj55r\\SSSjj55r\SSS
jj5r\SSj5rSrg)rVi�zZ
Performs signing and verification operations using
ECDSA and the specified hash function
r�rPrQrRc��Xlgr�r�r�s  rZr��ECAlgorithm.__init__�r�r\c��[U[[45(aU$[U[[45(d[S5e[
U5nURS5(a[U5nO[U5n[U[[45(d[S5SeU$![a
 [USS9nN?f=f)Nr�secdsa-sha2-r�zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for ECDSA algorithms)
rer&r(rjr�r�rr�r<r;r�r:r)rmrtr��
crypto_keys    rZru�ECAlgorithm.prepare_key�s����#� 7�9O�P�Q�Q��
��c�E�3�<�0�0�� @�A�A�#�C�(�I�

L��'�'��7�7�!4�Y�!?�J�!4�Y�!?�J�
��4�6L�M���&�y��������
L�1�)�d�K�
�
L�s�!B'�2B'�'B>�=B>c�~�URU[UR555n[X2R5$r�)r{r rar�curve)rmrzrt�der_sigs    rZr{�ECAlgorithm.signs,���h�h�s�E�$�-�-�/�$:�;�G�'����;�;r\c��[X2R5n[U[5(aUR5OUnUR
XA[UR555 g![a gf=f![a gf=f)NFT)
rrr�rer&rr�r rar)rmrzrtrrrs      rZr��ECAlgorithm.verifys���
�.�s�I�I�>��	
�"�#�'>�?�?��N�N�$���
�!�!�'��d�m�m�o�0F�G����
��
��$�
��
�s#�A)�AA9�)
A6�5A6�9
B�Bc��gr�rrr�s  rZr��ECAlgorithm.to_jwk'r�r\c��gr�rrr�s  rZr�r-r�r\c���[U[5(aUR5R5nO1[U[5(aUR5nO[S5e[UR[5(aSnO~[UR[5(aSnO\[UR[5(aSnO:[UR[5(aSnO[SUR35eSU[URURRS9R5[URURRS9R5S	.n[U[5(aG[UR!5R"URRS9R5US
'U(aU$[$R&"U5$)Nr��P-256�P-384�P-521�	secp256k1�Invalid curve: �EC)�
bit_length)r��crv�x�yr�)rer&rr�r(rrr"r#r$r!rr)�key_sizer�r*r��
private_valuer�r�)r�r�r�r(r�s     rZr�r3s{���'�#:�;�;�!(�!3�!3�!5�!D�!D�!F���G�%;�<�<�!(�!7�!7�!9��%�&C�D�D��'�-�-��3�3����G�M�M�9�5�5����G�M�M�9�5�5����G�M�M�9�5�5�!��%���
�
��&G�H�H���&�"�$�$�&�}�}�5�5���&�(�&�"�$�$�&�}�}�5�5���&�(�#�C��'�#:�;�;�,��+�+�-�;�;�&�}�}�5�5���&�(��C��
��
��z�z�#��&r\c�L�[U[5(a[R"U5nO[U[5(aUnO[
eURS5S:wa[
S5SeSU;dSU;a[
S5Se[URS55n[URS55nURS5nUS:Xa9[U5[U5s=:XaS	:XaO O[5nO�[
S
5SeUS:Xa9[U5[U5s=:XaS:XaO O[5nO�[
S
5SeUS:Xa9[U5[U5s=:XaS:XaO O[5nOX[
S5SeUS:Xa8[U5[U5s=:XaS	:XaO O[5nO[
S5e[
SU35e[[R!USS9[R!USS9US9nSU;aUR#5$[URS55n[U5[U5:wa[
S[U5U5e[%[R!USS9U5R'5$![
a
 [
S5Sef=f)Nr�r�r&zNot an Elliptic curve keyr)r*r(r!� z)Coords should be 32 bytes for curve P-256r"�0z)Coords should be 48 bytes for curve P-384r#�Bz)Coords should be 66 bytes for curve P-521r$z-Coords should be 32 bytes for curve secp256k1r%�big)�	byteorder)r)r*rr�z!D should be {} bytes for curve {})rer�r�r�r�r�rr�r�lenr"r#r$r!r)�int�
from_bytesrr'r)r�r�r)r*r�	curve_objr�r�s        rZr��ECAlgorithm.from_jwk_sd��
I��c�3�'�'��*�*�S�/�C���T�*�*��C�$�$��w�w�u�~��%�%�&A�B��L��#�~��C��%�&A�B��L� ������.�A� ������.�A��G�G�E�N�E�����q�6�S��V�)�r�)� )��I�)�C��� ��'�!��q�6�S��V�)�r�)� )��I�)�C��� ��'�!��q�6�S��V�)�r�)� )��I�)�C��� ��+�%��q�6�S��V�)�r�)� )��I�)�G���&���w�&?�@�@�7��.�.��e�.�4��.�.��e�.�4���N��#�~�%�0�0�2�2� ������.�A��1�v��Q���%�7��Q�����/����q�E��2�N���k�m�
��{�
I�%�&=�>�D�H�
I�s�+J�J�J�J#r�Nr
)rtzAllowedECKeys | str | bytesr��
AllowedECKeys)rzrjrtr&r�rj)rzrjrtr8rrjr�r�)r�r8r�r�r�rr�)r�r8r�r�r�r�)r�r8r�r�r�r�)r�r�r�r8)r�r�r�r�r�rrPr�rQrRr�rur{r�rr�r�r�r�rrr\rZrVrV�s���	�
8>�}�}��4�D�7=�}�}��4�D�7=�}�}��4�D�	%�	�<	<�
	�"
�	�	�"�	�-:�	�
�	�
�
�	�
�	�>C�	�"�	�-;�	�
�	�
�
�	�
�)	'�
�)	'�V
�G	�
�G	r\rVc�,�\rSrSrSrSSjrSSjrSrg)	rWi�z1
Performs a signature using RSASSA-PSS with MGF1
c	���URU[R"[R"UR	55UR	5R
S9UR	55$)N��mgf�salt_length)r{r�PSS�MGF1ra�digest_sizerys   rZr{�RSAPSSAlgorithm.sign�sN���8�8��������T�]�]�_�5� $�
�
�� ;� ;���
�
��
�
r\c
��URUU[R"[R"UR	55UR	5R
S9UR	55 g![a gf=f)Nr;TF)r�rr>r?rar@rr~s    rZr��RSAPSSAlgorithm.verify�sh��
��
�
����K�K�#�L�L�����9�$(�M�M�O�$?�$?���M�M�O����#�
��
�s�A/A2�2
A?�>A?rrNrr)r�r�r�r�r�r{r�r�rrr\rZrWrW�s��	�	�
	r\rWc���\rSrSrSrS
SjrSSjrSSjrSSjr\	\
SSj55r\	\
SSSjj55r\
SSS	jj5r\
SS
j5rSr
g)rXi�zv
Performs signing and verification operations using EdDSA

This class requires ``cryptography>=2.6`` to be installed.
c��gr�rr)rm�kwargss  rZr��OKPAlgorithm.__init__�s��r\c��[U[[45(a�[U[5(aURS5OUn[U[5(aUR	S5OUnSU;a[U5nO%SU;a[
USS9nOUSSS:Xa[U5n[U[[[[45(d[S5eU$)	N�utf-8z-----BEGIN PUBLICz-----BEGIN PRIVATEr�r�zssh-zcExpecting a EllipticCurvePrivateKey/EllipticCurvePublicKey. Wrong key provided for EdDSA algorithms)
rerjr�r��encoder;r:r<r,r-r*r+r)rmrt�key_strr�s    rZru�OKPAlgorithm.prepare_key�s����#��s�|�,�,�1;�C��1G�1G�#�*�*�W�-�S��3=�c�3�3G�3G�C�J�J�w�/�S�	�&�'�1�-�i�8�C�)�W�4�.�y�4�H�C��Q�q�\�V�+�-�i�8�C���"�$4�o�~�V���&�y����Jr\c�t�[U[5(aURS5OUnURU5$)a
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
rI)rer�rKr{)rmrzrt�	msg_bytess    rZr{�OKPAlgorithm.sign�s/��0:�#�s�/C�/C��
�
�7�+��I��8�8�I�&�&r\c�B�[U[5(aURS5OUn[U[5(aURS5OUn[U[[45(aUR5OUnUR
XT5 g![a gf=f)ap
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.
rITF)rer�rKr,r*rr�r)rmrzrtrrO�	sig_bytesrs       rZr��OKPAlgorithm.verify�s���
�3=�c�3�3G�3G�C�J�J�w�/�S�	�3=�c�3�3G�3G�C�J�J�w�/�S�	�"�#�(9�?�'K�L�L��N�N�$���
�!�!�)�7���#�
��
�s�BB�
B�Bc��gr�rr�rtr�s  rZr��OKPAlgorithm.to_jwkr�r\c��gr�rrrUs  rZr�rVr�r\c�t�[U[[45(a�UR[R
[R
S9n[U[5(aSOSn[[U55R5SUS.nU(aU$[R"U5$[U[[45(a�UR[R
[R
[!5S9nUR#5R[R
[R
S9n[U[5(aSOSn[[U55R5[[U55R5SUS.nU(aU$[R"U5$[%S5e)	N)�encoding�format�Ed25519�Ed448�OKP)r)r�r()rYrZ�encryption_algorithm)r)r�r�r(r�)rer-r+�public_bytesr6�Rawr9rrr�r�r�r,r*�
private_bytesr8r7rr)rtr�r)r(r�r�s      rZr�rVsh���#� 0�.�A�B�B��$�$�%�\�\�'�+�+�%���$.�c�3C�#D�#D�i�'��*�+�a�.�9�@�@�B� ������J��:�:�c�?�*��#� 1�?�C�D�D��%�%�%�\�\�(�,�,�)5��&����N�N�$�1�1�%�\�\�'�+�+�2���
$.�c�3D�#E�#E�i�7��)�+�a�.�9�@�@�B�)�+�a�.�9�@�@�B� ��	����J��:�:�c�?�*�!�"?�@�@r\c��[U[5(a[R"U5nO[U[5(aUnO[
eURS5S:wa[
S5eURS5nUS:waUS:wa[
SU35eS	U;a[
S
5e[URS	55nSU;a2US:Xa[R"U5$[R"U5$[URS55nUS:Xa[R"U5$[R"U5$![
a
 [
S5Sef=f![
an[
S5UeSnAff=f)
Nr�r�r]zNot an Octet Key Pairr(r[r\r%r)zOKP should have "x" parameterr�zInvalid key parameter)rer�r�r�r�r�rr�rr-�from_public_bytesr+r,�from_private_bytesr*)r�r�rr)r��errs      rZr��OKPAlgorithm.from_jwkJs`��
I��c�3�'�'��*�*�S�/�C���T�*�*��C�$�$��w�w�u�~��&�%�&=�>�>��G�G�E�N�E��	�!�e�w�&6�%���w�&?�@�@��#�~�%�&E�F�F� ������.�A�

H��c�>��	�)�/�A�A�!�D�D�)�;�;�A�>�>�$�S�W�W�S�\�2���I�%�,�?�?��B�B�&�9�9�!�<�<��-�
I�%�&=�>�D�H�
I��.�
H�%�&=�>�C�G��
H�s@�+E�E�E�!E!�%E!�;5E!�1E!�E�!
E<�+E7�7E<rrN)rFrr�r�)rtzAllowedOKPKeys | str | bytesr��AllowedOKPKeys)rzr�rtz#Ed25519PrivateKey | Ed448PrivateKeyr�rj)rzr�rtrgrr�r�r�)rtrgr�r�r�rr�)rtrgr�r�r�r�)rtrgr�r�r�r�)r�r�r�rg)r�r�r�r�r�r�rur{r�rr�r�r�r�rrr\rZrXrX�s���	�	�	�.	'�"�	'�)L�	'�
�	'�	�"�	�)7�	�>I�	�
�	�4
�	�	��	�*7�	�
�	�
�
�	�
�	�;@�	��	�*8�	�
�	�
�
�	�
�,	A�
�,	A�\
� 	H�
� 	Hr\rX)r�zdict[str, Algorithm])[�
__future__rr�r�r��abcrr�typingrrrr	r
rr�
exceptionsr�typesrr�utilsrrrrrrrrr�cryptography.exceptionsrr�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/r0r1r2r3r4r5�,cryptography.hazmat.primitives.serializationr6r7r8r9r:r;r<rS�ModuleNotFoundErrorrr8rg�AllowedKeys�AllowedPrivateKeys�AllowedPublicKeys�requires_cryptographyr[r^rNrOrUrVrWrXrrr\rZ�<module>r|s���"����#�R�R�R�'�'�
�
�
�/�N�<�5�A������	�	�	�����J�
�"�\�1�N�+�.D�D�M��,�,��>��O��!�=�0�>�A�K��/�/�2C�C�o�U��	�-�-�0@�@�>�Q��

�� �DF��F�R$�I�$�<E=�I�E=�P�h�y�h�TA�i�A�F�,��<dH�y�dH�[��k���J��s�A*E�E �E 

Filemanager

Name Type Size Permission Actions
__init__.cpython-313.pyc File 1.57 KB 0644
algorithms.cpython-313.pyc File 34.11 KB 0644
api_jwk.cpython-313.pyc File 6.79 KB 0644
api_jws.cpython-313.pyc File 13.45 KB 0644
api_jwt.cpython-313.pyc File 14.73 KB 0644
exceptions.cpython-313.pyc File 3.86 KB 0644
help.cpython-313.pyc File 2.13 KB 0644
jwk_set_cache.cpython-313.pyc File 1.77 KB 0644
jwks_client.cpython-313.pyc File 5.64 KB 0644
types.cpython-313.pyc File 297 B 0644
utils.cpython-313.pyc File 5.47 KB 0644
warnings.cpython-313.pyc File 410 B 0644
Filemanager