File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/asymmetric.tar
Back
dh.py 0000644 00000014237 15030211711 0005507 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import typing from cryptography import utils from cryptography.hazmat.backends import _get_backend from cryptography.hazmat.primitives import serialization _MIN_MODULUS_SIZE = 512 def generate_parameters(generator, key_size, backend=None) -> "DHParameters": backend = _get_backend(backend) return backend.generate_dh_parameters(generator, key_size) class DHParameterNumbers(object): def __init__(self, p: int, g: int, q: typing.Optional[int] = None): if not isinstance(p, int) or not isinstance(g, int): raise TypeError("p and g must be integers") if q is not None and not isinstance(q, int): raise TypeError("q must be integer or None") if g < 2: raise ValueError("DH generator must be 2 or greater") if p.bit_length() < _MIN_MODULUS_SIZE: raise ValueError( "p (modulus) must be at least {}-bit".format(_MIN_MODULUS_SIZE) ) self._p = p self._g = g self._q = q def __eq__(self, other): if not isinstance(other, DHParameterNumbers): return NotImplemented return ( self._p == other._p and self._g == other._g and self._q == other._q ) def __ne__(self, other): return not self == other def parameters(self, backend=None): backend = _get_backend(backend) return backend.load_dh_parameter_numbers(self) p = utils.read_only_property("_p") g = utils.read_only_property("_g") q = utils.read_only_property("_q") class DHPublicNumbers(object): def __init__(self, y, parameter_numbers: DHParameterNumbers): if not isinstance(y, int): raise TypeError("y must be an integer.") if not isinstance(parameter_numbers, DHParameterNumbers): raise TypeError( "parameters must be an instance of DHParameterNumbers." ) self._y = y self._parameter_numbers = parameter_numbers def __eq__(self, other): if not isinstance(other, DHPublicNumbers): return NotImplemented return ( self._y == other._y and self._parameter_numbers == other._parameter_numbers ) def __ne__(self, other): return not self == other def public_key(self, backend=None) -> "DHPublicKey": backend = _get_backend(backend) return backend.load_dh_public_numbers(self) y = utils.read_only_property("_y") parameter_numbers = utils.read_only_property("_parameter_numbers") class DHPrivateNumbers(object): def __init__(self, x, public_numbers: DHPublicNumbers): if not isinstance(x, int): raise TypeError("x must be an integer.") if not isinstance(public_numbers, DHPublicNumbers): raise TypeError( "public_numbers must be an instance of " "DHPublicNumbers." ) self._x = x self._public_numbers = public_numbers def __eq__(self, other): if not isinstance(other, DHPrivateNumbers): return NotImplemented return ( self._x == other._x and self._public_numbers == other._public_numbers ) def __ne__(self, other): return not self == other def private_key(self, backend=None) -> "DHPrivateKey": backend = _get_backend(backend) return backend.load_dh_private_numbers(self) public_numbers = utils.read_only_property("_public_numbers") x = utils.read_only_property("_x") class DHParameters(metaclass=abc.ABCMeta): @abc.abstractmethod def generate_private_key(self) -> "DHPrivateKey": """ Generates and returns a DHPrivateKey. """ @abc.abstractmethod def parameter_bytes( self, encoding: "serialization.Encoding", format: "serialization.ParameterFormat", ) -> bytes: """ Returns the parameters serialized as bytes. """ @abc.abstractmethod def parameter_numbers(self) -> DHParameterNumbers: """ Returns a DHParameterNumbers. """ DHParametersWithSerialization = DHParameters class DHPublicKey(metaclass=abc.ABCMeta): @abc.abstractproperty def key_size(self) -> int: """ The bit length of the prime modulus. """ @abc.abstractmethod def parameters(self) -> DHParameters: """ The DHParameters object associated with this public key. """ @abc.abstractmethod def public_numbers(self) -> DHPublicNumbers: """ Returns a DHPublicNumbers. """ @abc.abstractmethod def public_bytes( self, encoding: "serialization.Encoding", format: "serialization.PublicFormat", ) -> bytes: """ Returns the key serialized as bytes. """ DHPublicKeyWithSerialization = DHPublicKey class DHPrivateKey(metaclass=abc.ABCMeta): @abc.abstractproperty def key_size(self) -> int: """ The bit length of the prime modulus. """ @abc.abstractmethod def public_key(self) -> DHPublicKey: """ The DHPublicKey associated with this private key. """ @abc.abstractmethod def parameters(self) -> DHParameters: """ The DHParameters object associated with this private key. """ @abc.abstractmethod def exchange(self, peer_public_key: DHPublicKey) -> bytes: """ Given peer's DHPublicKey, carry out the key exchange and return shared key as bytes. """ @abc.abstractmethod def private_numbers(self) -> DHPrivateNumbers: """ Returns a DHPrivateNumbers. """ @abc.abstractmethod def private_bytes( self, encoding: "serialization.Encoding", format: "serialization.PrivateFormat", encryption_algorithm: "serialization.KeySerializationEncryption", ) -> bytes: """ Returns the key serialized as bytes. """ DHPrivateKeyWithSerialization = DHPrivateKey ed25519.py 0000644 00000005237 15030211711 0006112 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc from cryptography.exceptions import UnsupportedAlgorithm, _Reasons from cryptography.hazmat.primitives import _serialization _ED25519_KEY_SIZE = 32 _ED25519_SIG_SIZE = 64 class Ed25519PublicKey(metaclass=abc.ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> "Ed25519PublicKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed25519_supported(): raise UnsupportedAlgorithm( "ed25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed25519_load_public_bytes(data) @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ The serialized bytes of the public key. """ @abc.abstractmethod def verify(self, signature: bytes, data: bytes) -> None: """ Verify the signature. """ class Ed25519PrivateKey(metaclass=abc.ABCMeta): @classmethod def generate(cls) -> "Ed25519PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed25519_supported(): raise UnsupportedAlgorithm( "ed25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed25519_generate_key() @classmethod def from_private_bytes(cls, data: bytes) -> "Ed25519PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed25519_supported(): raise UnsupportedAlgorithm( "ed25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed25519_load_private_bytes(data) @abc.abstractmethod def public_key(self) -> Ed25519PublicKey: """ The Ed25519PublicKey derived from the private key. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ): """ The serialized bytes of the private key. """ @abc.abstractmethod def sign(self, data: bytes) -> bytes: """ Signs the data. """ __pycache__/x25519.cpython-310.pyc 0000644 00000005167 15030211711 0012332 0 ustar 00 o -&%a � @ sP d dl Z d dlmZmZ d dlmZ G dd� de jd�ZG dd� de jd�ZdS ) � N)�UnsupportedAlgorithm�_Reasons)�_serializationc @ sB e Zd Zededd fdd��Zejdej dej defdd��Z d S ) �X25519PublicKey�data�returnc C �* ddl m} |�� stdtj��|�|�S �Nr )�backendz3X25519 is not supported by this version of OpenSSL.)�,cryptography.hazmat.backends.openssl.backendr �x25519_supportedr r � UNSUPPORTED_EXCHANGE_ALGORITHM�x25519_load_public_bytes��clsr r � r �R/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/x25519.py�from_public_bytes � � z!X25519PublicKey.from_public_bytes�encoding�formatc C � dS �z9 The serialized bytes of the public key. Nr )�selfr r r r r � public_bytes � z X25519PublicKey.public_bytesN) �__name__� __module__� __qualname__� classmethod�bytesr �abc�abstractmethodr �Encoding� PublicFormatr r r r r r s ���r )� metaclassc @ s� e Zd Zeddd��Zededd fdd��Zejde fdd��Z ejd e j d e j d e jdefd d ��Zejde defdd��ZdS )�X25519PrivateKeyr c C s( ddl m} |�� stdtj��|�� S r )r r r r r r �x25519_generate_key)r r r r r �generate% s �zX25519PrivateKey.generater c C r r )r r r r r r �x25519_load_private_bytesr r r r �from_private_bytes0 r z#X25519PrivateKey.from_private_bytesc C r r r )r r r r � public_key< r zX25519PrivateKey.public_keyr r �encryption_algorithmc C r )z: The serialized bytes of the private key. Nr )r r r r, r r r � private_bytesB r z X25519PrivateKey.private_bytes�peer_public_keyc C r )zY Performs a key exchange operation using the provided peer's public key. Nr )r r. r r r �exchangeM r zX25519PrivateKey.exchangeN)r r& )r r r r r( r r* r! r" r r+ r r# � PrivateFormat�KeySerializationEncryptionr- r/ r r r r r& $ s& ��� � r& ) r! �cryptography.exceptionsr r � cryptography.hazmat.primitivesr �ABCMetar r& r r r r �<module> s __pycache__/dsa.cpython-310.pyc 0000644 00000022226 15030211711 0012217 0 ustar 00 o �)%a� � @ s d dl Z d dlZd dlmZ d dlmZ d dlmZmZ d dl m Z m Z mZ G dd� de j d�ZeZG d d � d e j d�ZeZG d d � d e j d�ZeZG d d� de�ZG dd� de�ZG dd� de�Zd dedefdd�Zd dedefdd�Zdefdd�Zd efd d �Z dS ) � N)�utils)� _get_backend)�_serialization�hashes)�AsymmetricSignatureContext� AsymmetricVerificationContextr c @ s, e Zd Zejd dd��Zejd dd��ZdS ) � DSAParameters�return� DSAPrivateKeyc C � dS )z8 Generates and returns a DSAPrivateKey. N� ��selfr r �O/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/dsa.py�generate_private_key � z"DSAParameters.generate_private_key�DSAParameterNumbersc C r )z0 Returns a DSAParameterNumbers. Nr r r r r �parameter_numbers r z DSAParameters.parameter_numbersN)r r )r r )�__name__� __module__� __qualname__�abc�abstractmethodr r r r r r r s r )� metaclassc @ s� e Zd Zejdefdd��Zejddd��Zejde fdd��Z ejd e j de fd d ��Zejd ed ejeje j f defdd��Zejddd��Zejdejdejdejdefdd��ZdS )r r c C r �z6 The bit length of the prime modulus. Nr r r r r �key_size% r zDSAPrivateKey.key_size� DSAPublicKeyc C r )zD The DSAPublicKey associated with this private key. Nr r r r r � public_key+ r zDSAPrivateKey.public_keyc C r )zL The DSAParameters object associated with this private key. Nr r r r r � parameters1 r zDSAPrivateKey.parameters�signature_algorithmc C r )zN Returns an AsymmetricSignatureContext used for signing data. Nr )r r r r r �signer7 r zDSAPrivateKey.signer�data� algorithmc C r )z Signs the data Nr )r r! r" r r r �sign@ r zDSAPrivateKey.sign�DSAPrivateNumbersc C r )z. Returns a DSAPrivateNumbers. Nr r r r r �private_numbersJ r z DSAPrivateKey.private_numbers�encoding�format�encryption_algorithmc C r �z6 Returns the key serialized as bytes. Nr )r r& r' r( r r r � private_bytesP r zDSAPrivateKey.private_bytesN)r r )r r$ )r r r r �abstractproperty�intr r r r r r � HashAlgorithmr r �bytes�typing�Union� asym_utils� Prehashedr# r% r �Encoding� PrivateFormat�KeySerializationEncryptionr* r r r r r $ sB � ��� � ����r c @ s� e Zd Zejdefdd��Zejdefdd��Z ejde de j de fdd ��Zejdd d ��Zejd ejdejde fdd��Zejde de dejeje j f fdd��ZdS )r r c C r r r r r r r r ` r zDSAPublicKey.key_sizec C r )zK The DSAParameters object associated with this public key. Nr r r r r r f r zDSAPublicKey.parameters� signaturer c C r )zQ Returns an AsymmetricVerificationContext used for signing data. Nr )r r6 r r r r �verifierl r zDSAPublicKey.verifier�DSAPublicNumbersc C r )z- Returns a DSAPublicNumbers. Nr r r r r �public_numbersv r zDSAPublicKey.public_numbersr& r' c C r r) r )r r& r' r r r � public_bytes| r zDSAPublicKey.public_bytesr! r" c C r )z5 Verifies the signature of the data. Nr )r r6 r! r" r r r �verify� r zDSAPublicKey.verifyN)r r8 )r r r r r+ r, r r r r r. r r- r r7 r9 r r3 � PublicFormatr: r/ r0 r1 r2 r; r r r r r _ s> �� � �� � ���r c @ sh e Zd Zdededefdd�Ze�d�Ze�d�Ze�d�Z dd e fd d �Z d d� Z dd� Z dd� Zd S )r �p�q�gc C s< t |t�rt |t�rt |t�std��|| _|| _|| _d S )Nz;DSAParameterNumbers p, q, and g arguments must be integers.)� isinstancer, � TypeError�_p�_q�_g)r r= r> r? r r r �__init__� s ���� z DSAParameterNumbers.__init__rB rC rD Nr c C � t |�}|�| �S �N)r �load_dsa_parameter_numbers�r �backendr r r r � � z DSAParameterNumbers.parametersc C s2 t |t�stS | j|jko| j|jko| j|jkS rG )r@ r �NotImplementedr= r> r? �r �otherr r r �__eq__� s $zDSAParameterNumbers.__eq__c C � | |k S rG r rM r r r �__ne__� � zDSAParameterNumbers.__ne__c C � dj | d�S )Nz9<DSAParameterNumbers(p={self.p}, q={self.q}, g={self.g})>r �r' r r r r �__repr__� � ��z DSAParameterNumbers.__repr__rG )r r r r, rE r �read_only_propertyr= r> r? r r rO rQ rU r r r r r � s r c @ sZ e Zd Zdedefdd�Ze�d�Ze�d�Z dde fd d �Z d d � Z d d� Z dd� ZdS )r8 �yr c C s4 t |t�s td��t |t�std��|| _|| _d S )Nz/DSAPublicNumbers y argument must be an integer.z9parameter_numbers must be a DSAParameterNumbers instance.)r@ r, rA r �_y�_parameter_numbers)r rX r r r r rE � s � zDSAPublicNumbers.__init__rY rZ Nr c C rF rG )r �load_dsa_public_numbersrI r r r r � rK zDSAPublicNumbers.public_keyc C �& t |t�stS | j|jko| j|jkS rG )r@ r8 rL rX r rM r r r rO � s �zDSAPublicNumbers.__eq__c C rP rG r rM r r r rQ � rR zDSAPublicNumbers.__ne__c C rS )NzJ<DSAPublicNumbers(y={self.y}, parameter_numbers={self.parameter_numbers})>r rT r r r r rU � rV zDSAPublicNumbers.__repr__rG )r r r r, r rE r rW rX r r r rO rQ rU r r r r r8 � s r8 c @ sR e Zd Zdedefdd�Ze�d�Ze�d�Z dde fd d �Z d d � Z d d� Z dS )r$ �xr9 c C s4 t |t�s td��t |t�std��|| _|| _d S )Nz0DSAPrivateNumbers x argument must be an integer.z3public_numbers must be a DSAPublicNumbers instance.)r@ r, rA r8 �_public_numbers�_x)r r] r9 r r r rE � s � zDSAPrivateNumbers.__init__r_ r^ Nr c C rF rG )r �load_dsa_private_numbersrI r r r � private_key� rK z DSAPrivateNumbers.private_keyc C r\ rG )r@ r$ rL r] r9 rM r r r rO � s �zDSAPrivateNumbers.__eq__c C rP rG r rM r r r rQ � rR zDSAPrivateNumbers.__ne__rG )r r r r, r8 rE r rW r] r9 r ra rO rQ r r r r r$ � s r$ r r c C rF rG )r �generate_dsa_parameters�r rJ r r r �generate_parameters rK rd c C rF rG )r �'generate_dsa_private_key_and_parametersrc r r r r rK r r c C sX | j �� dvr td��| j�� dvrtd��d| j k r%| j k s*td�� td��d S )N)i i i i z5p must be exactly 1024, 2048, 3072, or 4096 bits long)� �� � z,q must be exactly 160, 224, or 256 bits long� z g, p don't satisfy 1 < g < p.)r= � bit_length� ValueErrorr> r? )r r r r �_check_dsa_parameters s ���rl �numbersc C sT | j j}t|� | jdks| j|jkrtd��| j jt|j| j|j �kr(td��d S )Nr zx must be > 0 and < q.z y must be equal to (g ** x % p).) r9 r rl r] r> rk rX �powr? r= )rm r r r r �_check_dsa_private_numbers s �ro rG ) r r/ � cryptographyr � cryptography.hazmat.backendsr � cryptography.hazmat.primitivesr r �)cryptography.hazmat.primitives.asymmetricr r r1 �ABCMetar �DSAParametersWithNumbersr � DSAPrivateKeyWithSerializationr � DSAPublicKeyWithSerialization�objectr r8 r$ r, rd r rl ro r r r r �<module> s& 83'' __pycache__/__init__.cpython-310.pyc 0000644 00000002527 15030211711 0013211 0 ustar 00 o �)%a� � @ s4 d dl Z G dd� de jd�ZG dd� de jd�ZdS )� Nc @ �( e Zd Zejdd� �Zejdd� �ZdS )�AsymmetricSignatureContextc C � dS �zC Processes the provided bytes and returns nothing. N� ��self�datar r �T/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/__init__.py�update � z!AsymmetricSignatureContext.updatec C r )z1 Returns the signature as bytes. Nr �r r r r �finalize r z#AsymmetricSignatureContext.finalizeN)�__name__� __module__� __qualname__�abc�abstractmethodr r r r r r r � r )� metaclassc @ r )� AsymmetricVerificationContextc C r r r r r r r r r z$AsymmetricVerificationContext.updatec C r )z� Raises an exception if the bytes provided to update do not match the signature or the signature does not match the public key. Nr r r r r �verify r z$AsymmetricVerificationContext.verifyN)r r r r r r r r r r r r r r )r �ABCMetar r r r r r �<module> s __pycache__/ed25519.cpython-310.pyc 0000644 00000005570 15030211711 0012451 0 ustar 00 o �)%a� � @ sX d dl Z d dlmZmZ d dlmZ dZdZG dd� de jd�Z G d d � d e jd�Z dS ) � N)�UnsupportedAlgorithm�_Reasons)�_serialization� �@ c @ s^ e Zd Zededd fdd��Zejdej dej defdd��Z ejd ededd fd d ��Z d S ) �Ed25519PublicKey�data�returnc C �* ddl m} |�� stdtj��|�|�S �Nr )�backendz4ed25519 is not supported by this version of OpenSSL.)�,cryptography.hazmat.backends.openssl.backendr �ed25519_supportedr r � UNSUPPORTED_PUBLIC_KEY_ALGORITHM�ed25519_load_public_bytes��clsr r � r �S/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py�from_public_bytes � � z"Ed25519PublicKey.from_public_bytes�encoding�formatc C � dS )z9 The serialized bytes of the public key. Nr )�selfr r r r r � public_bytes � z Ed25519PublicKey.public_bytes� signatureNc C r )z' Verify the signature. Nr )r r r r r r �verify' r zEd25519PublicKey.verify) �__name__� __module__� __qualname__� classmethod�bytesr �abc�abstractmethodr �Encoding� PublicFormatr r r r r r r s �� � r )� metaclassc @ s~ e Zd Zeddd��Zededd fdd��Zejde fdd��Z ejd e j d e j d e jfd d ��Zejdedefdd��ZdS )�Ed25519PrivateKeyr c C s( ddl m} |�� stdtj��|�� S r )r r r r r r �ed25519_generate_key)r r r r r �generate/ s �zEd25519PrivateKey.generater c C r r )r r r r r r �ed25519_load_private_bytesr r r r �from_private_bytes; r z$Ed25519PrivateKey.from_private_bytesc C r )zD The Ed25519PublicKey derived from the private key. Nr )r r r r � public_keyG r z Ed25519PrivateKey.public_keyr r �encryption_algorithmc C r )z: The serialized bytes of the private key. Nr )r r r r/ r r r � private_bytesM r z Ed25519PrivateKey.private_bytesc C r )z! Signs the data. Nr )r r r r r �signX r zEd25519PrivateKey.signN)r r) )r r r! r" r+ r# r- r$ r% r r. r r& � PrivateFormat�KeySerializationEncryptionr0 r1 r r r r r) . s" �� � r) ) r$ �cryptography.exceptionsr r � cryptography.hazmat.primitivesr �_ED25519_KEY_SIZE�_ED25519_SIG_SIZE�ABCMetar r) r r r r �<module> s __pycache__/padding.cpython-310.pyc 0000644 00000004622 15030211711 0013056 0 ustar 00 o -&%aC � @ s� d dl Z d dlmZ d dlmZ d dlmZ G dd� de�ZG dd� de�ZG d d � d e�Z G d d � d e �Z d e j d dej defdd�ZdS )� N)�hashes)�AsymmetricPadding)�rsac @ s e Zd ZdZdS )�PKCS1v15zEMSA-PKCS1-v1_5N)�__name__� __module__� __qualname__�name� r r �S/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/padding.pyr s r c @ s e Zd Ze� ZdZdd� ZdS )�PSSzEMSA-PSSc C sF || _ t|t�s|| jurtd��|| jur |dk r td��|| _d S )Nz salt_length must be an integer.r z$salt_length must be zero or greater.)�_mgf� isinstance�int� MAX_LENGTH� TypeError� ValueError� _salt_length)�self�mgf� salt_lengthr r r �__init__ s � z PSS.__init__N)r r r �objectr r r r r r r r s r c @ s. e Zd ZdZdddejdeje fdd�Z dS ) �OAEPzEME-OAEPr �MGF1� algorithm�labelc C s* t |tj�s td��|| _|| _|| _d S �Nz*Expected instance of hashes.HashAlgorithm.)r r � HashAlgorithmr r � _algorithm�_label)r r r r r r r r ' s z OAEP.__init__N) r r r r r r �typing�Optional�bytesr r r r r r $ s ���r c @ s" e Zd Ze� Zdejfdd�ZdS )r r c C s t |tj�s td��|| _d S r )r r r r r )r r r r r r 8 s z MGF1.__init__N)r r r r r r r r r r r r r 5 s r �key)zrsa.RSAPrivateKeyzrsa.RSAPublicKey�hash_algorithm�returnc C sF t | tjtjf�s td��| jd d }||j d }|dks!J �|S )Nz(key must be an RSA public or private key� � � r )r r � RSAPrivateKey� RSAPublicKeyr �key_size� digest_size)r$ r% �emlenr r r r � calculate_max_pss_salt_length? s r/ )r! � cryptography.hazmat.primitivesr �*cryptography.hazmat.primitives._asymmetricr �)cryptography.hazmat.primitives.asymmetricr r r r r r �Unionr r r/ r r r r �<module> s ��� __pycache__/x448.cpython-310.pyc 0000644 00000005130 15030211711 0012152 0 ustar 00 o �)%a� � @ sP d dl Z d dlmZmZ d dlmZ G dd� de jd�ZG dd� de jd�ZdS ) � N)�UnsupportedAlgorithm�_Reasons)�_serializationc @ s: e Zd Zed dd��Zejdejdej de fdd��Z dS ) � X448PublicKey�returnc C �* ddl m} |�� stdtj��|�|�S �Nr )�backendz1X448 is not supported by this version of OpenSSL.)�,cryptography.hazmat.backends.openssl.backendr �x448_supportedr r � UNSUPPORTED_EXCHANGE_ALGORITHM�x448_load_public_bytes��cls�datar � r �P/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/x448.py�from_public_bytes � � z X448PublicKey.from_public_bytes�encoding�formatc C � dS �z9 The serialized bytes of the public key. Nr )�selfr r r r r � public_bytes � zX448PublicKey.public_bytesN)r r ) �__name__� __module__� __qualname__� classmethodr �abc�abstractmethodr �Encoding� PublicFormat�bytesr r r r r r s ���r )� metaclassc @ s� e Zd Zeddd��Zededd fdd��Zejde fdd��Z ejd e j d e j d e jdefd d ��Zejde defdd��ZdS )�X448PrivateKeyr c C s( ddl m} |�� stdtj��|�� S r )r r r r r r �x448_generate_key)r r r r r �generate% s �zX448PrivateKey.generater c C r r )r r r r r r �x448_load_private_bytesr r r r �from_private_bytes0 r z!X448PrivateKey.from_private_bytesc C r r r )r r r r � public_key< r zX448PrivateKey.public_keyr r �encryption_algorithmc C r )z: The serialized bytes of the private key. Nr )r r r r, r r r � private_bytesB r z X448PrivateKey.private_bytes�peer_public_keyc C r )zY Performs a key exchange operation using the provided peer's public key. Nr )r r. r r r �exchangeM r zX448PrivateKey.exchangeN)r r& )r r r r r( r$ r* r r! r r+ r r" � PrivateFormat�KeySerializationEncryptionr- r/ r r r r r& $ s& ��� � r& ) r �cryptography.exceptionsr r � cryptography.hazmat.primitivesr �ABCMetar r& r r r r �<module> s __pycache__/utils.cpython-310.pyc 0000644 00000002734 15030211711 0012612 0 ustar 00 o �)%a� � @ s� d dl Z d dlmZ d dlmZmZmZmZmZ d dl m Z de de j e e f fdd�Zd e d e de fd d �ZG d d� de�ZdS )� N)�utils)� DERReader�INTEGER�SEQUENCE� encode_der�encode_der_integer)�hashes� signature�returnc C sV t | ��t��}|�t��� }|�t��� }||fW d � S 1 s$w Y d S �N)r �read_single_elementr � read_elementr � as_integer)r �seq�r�s� r �Q/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/utils.py�decode_dss_signature s $�r r r c C s t tt tt| ��t tt|���S r )r r r r )r r r r r �encode_dss_signature s �r c @ s& e Zd Zdejfdd�Ze�d�ZdS )� Prehashed� algorithmc C s& t |tj�s td��|| _|j| _d S )Nz#Expected instance of HashAlgorithm.)� isinstancer � HashAlgorithm� TypeError� _algorithm� digest_size� _digest_size)�selfr r r r �__init__# s zPrehashed.__init__r N) �__name__� __module__� __qualname__r r r r �read_only_propertyr r r r r r " s r )�typing� cryptographyr �cryptography.hazmat._derr r r r r � cryptography.hazmat.primitivesr �bytes�Tuple�intr r �objectr r r r r �<module> s __pycache__/rsa.cpython-310.pyc 0000644 00000026446 15030211711 0012245 0 ustar 00 o �)%a�. � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZmZ d dl m Z d dl m Z d dl mZmZ d dlmZ d d lmZmZmZ G d d � d e jd �ZeZG d d� de jd �ZeZ d4dededefdd�Z dededdfdd�Z dededededededed eddfd d �Z d ed eddfd!d"�Z d ed#edefd$d%�Z dededefd&d'�Z!dededefd(d)�Z"dededefd*d+�Z#d,Z$d ed ed-edej%eef fd.d/�Z&G d0d1� d1e'�Z(G d2d3� d3e'�Z)dS )5� N)�gcd)�utils)�UnsupportedAlgorithm�_Reasons)� _get_backend)� RSABackend)�_serialization�hashes)�AsymmetricPadding)�AsymmetricSignatureContext� AsymmetricVerificationContextr c @ s� e Zd Zejdedejdefdd��Z ejde dede fdd��Z ej de fd d ��Zejdd d ��Zejde dedejejejf de fdd��Zejddd��Zejdejdejdejde fdd��ZdS ) � RSAPrivateKey�padding� algorithm�returnc C � dS )zN Returns an AsymmetricSignatureContext used for signing data. N� )�selfr r r r �O/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/rsa.py�signer � zRSAPrivateKey.signer� ciphertextc C r )z3 Decrypts the provided ciphertext. Nr )r r r r r r �decrypt r zRSAPrivateKey.decryptc C r �z7 The bit length of the public modulus. Nr �r r r r �key_size& r zRSAPrivateKey.key_size� RSAPublicKeyc C r )zD The RSAPublicKey associated with this private key. Nr r r r r � public_key, r zRSAPrivateKey.public_key�datac C r )z! Signs the data. Nr )r r r r r r r �sign2 r zRSAPrivateKey.sign�RSAPrivateNumbersc C r )z/ Returns an RSAPrivateNumbers. Nr r r r r �private_numbers= r z RSAPrivateKey.private_numbers�encoding�format�encryption_algorithmc C r �z6 Returns the key serialized as bytes. Nr )r r" r# r$ r r r � private_bytesC r zRSAPrivateKey.private_bytesN)r r )r r )�__name__� __module__� __qualname__�abc�abstractmethodr r � HashAlgorithmr r �bytesr �abstractproperty�intr r �typing�Union� asym_utils� Prehashedr r! r �Encoding� PrivateFormat�KeySerializationEncryptionr& r r r r r sJ �� � ��� � ����r )� metaclassc @ s� e Zd Zejdededejde fdd��Z ejdededefdd ��Z ej de fd d ��Zejdd d��Zejdejdejdefdd��Zejdedededejejejf ddf dd��Zejdededejej defdd��ZdS )r � signaturer r r c C r )zY Returns an AsymmetricVerificationContext used for verifying signatures. Nr �r r8 r r r r r �verifierS r zRSAPublicKey.verifier� plaintextc C r )z/ Encrypts the given plaintext. Nr )r r; r r r r �encrypt^ r zRSAPublicKey.encryptc C r r r r r r r r d r zRSAPublicKey.key_size�RSAPublicNumbersc C r )z- Returns an RSAPublicNumbers Nr r r r r �public_numbersj r zRSAPublicKey.public_numbersr" r# c C r r% r )r r" r# r r r � public_bytesp r zRSAPublicKey.public_bytesr Nc C r )z5 Verifies the signature of the data. Nr )r r8 r r r r r r �verifyz r zRSAPublicKey.verifyc C r )z@ Recovers the original data from the signature. Nr r9 r r r �recover_data_from_signature� r z(RSAPublicKey.recover_data_from_signature)r r= )r' r( r) r* r+ r- r r r, r r: r< r. r/ r r> r r4 � PublicFormatr? r0 r1 r2 r3 r@ �OptionalrA r r r r r R s^ ��� � �� � ���� � �� ��r �public_exponentr r c C s4 t |�}t|t�stdtj��t| |� |�| |�S )Nz-Backend object does not implement RSABackend.)r � isinstancer r r �BACKEND_MISSING_INTERFACE�_verify_rsa_parameters�generate_rsa_private_key)rD r �backendr r r �generate_private_key� s � rJ c C s$ | dvrt d��|dk rt d��d S )N)� i zopublic_exponent must be either 3 (for legacy compatibility) or 65537. Almost everyone should choose 65537 here!i z#key_size must be at least 512-bits.�� ValueError)rD r r r r rG � s ��rG �p�q�private_exponent�dmp1�dmq1�iqmp�modulusc C s� |dk rt d��| |krt d��||krt d��||kr t d��||kr(t d��||kr0t d��||kr8t d��|dk s@||krDt d ��|d @ d krNt d ��|d @ d krXt d ��|d @ d krbt d��| | |krlt d��d S )NrK zmodulus must be >= 3.zp must be < modulus.zq must be < modulus.zdmp1 must be < modulus.zdmq1 must be < modulus.ziqmp must be < modulus.z#private_exponent must be < modulus.z+public_exponent must be >= 3 and < modulus.� r z public_exponent must be odd.zdmp1 must be odd.zdmq1 must be odd.zp*q must equal modulus.rL )rN rO rP rQ rR rS rD rT r r r � _check_private_key_components� s2 �rV �e�nc C s@ |dk rt d��| dk s| |krt d��| d@ dkr t d��d S )NrK zn must be >= 3.ze must be >= 3 and < n.rU r ze must be odd.rL )rW rX r r r � _check_public_key_components� s �rY �mc C sX d\}}| |}}|dkr(t ||�\}}||| }||||f\}}}}|dks || S )zO Modular Multiplicative Inverse. Returns x such that: (x*e) mod m == 1 )rU r r )�divmod) rW rZ �x1�x2�a�brO �r�xnr r r �_modinv� s �rb c C s t || �S )zF Compute the CRT (q ** -1) % p value from RSA primes p and q. )rb )rN rO r r r � rsa_crt_iqmp� s rc c C � | |d S )zg Compute the CRT private_exponent % (p - 1) value from the RSA private_exponent (d) and p. rU r )rP rN r r r � rsa_crt_dmp1� � re c C rd )zg Compute the CRT private_exponent % (q - 1) value from the RSA private_exponent (d) and q. rU r )rP rO r r r � rsa_crt_dmq1 rf rg i� �dc C s� || d }|}|d dkr|d }|d dksd}d}|s\|t k r\|}||k rRt||| �}|dkrJ|| d krJt|d| �dkrJt|d | �} d}n|d9 }||k s(|d7 }|s\|t k s"|sbtd��t| | �\} } | dksoJ �t| | fdd�\} } | | fS )z� Compute factors p and q from the private exponent d. We assume that n has no more than two factors. This function is adapted from code in PyCrypto. rU � r FTz2Unable to compute factors p and q from exponent d.)�reverse)�_MAX_RECOVERY_ATTEMPTS�powr rM r[ �sorted) rX rW rh �ktot�t�spottedr^ �k�candrN rO r` r r r �rsa_recover_prime_factors s2 � $� � rs c @ s� e Zd Zdededededededdfd d �Ze�d �Ze�d �Ze�d �Z e�d�Z e�d�Z e�d�Z e�d�Z d defdd�Zdd� Zdd� Zdd� ZdS ) r rN rO rh rQ rR rS r> r= c C s� t |t�r t |t�r t |t�r t |t�r t |t�r t |t�s"td��t |t�s+td��|| _|| _|| _|| _|| _|| _ || _ d S )NzNRSAPrivateNumbers p, q, d, dmp1, dmq1, iqmp arguments must all be an integers.zFRSAPrivateNumbers public_numbers must be an RSAPublicNumbers instance.) rE r/ � TypeErrorr= �_p�_q�_d�_dmp1�_dmq1�_iqmp�_public_numbers)r rN rO rh rQ rR rS r> r r r �__init__@ s4 ������� � zRSAPrivateNumbers.__init__ru rv rw rx ry rz r{ Nr c C � t |�}|�| �S �N)r �load_rsa_private_numbers�r rI r r r � private_keym � z RSAPrivateNumbers.private_keyc C sb t |t�stS | j|jko0| j|jko0| j|jko0| j|jko0| j|jko0| j|jko0| j |j kS r~ ) rE r �NotImplementedrN rO rh rQ rR rS r> �r �otherr r r �__eq__q s � � � � � �zRSAPrivateNumbers.__eq__c C � | |k S r~ r r� r r r �__ne__ � zRSAPrivateNumbers.__ne__c C s$ t | j| j| j| j| j| j| jf�S r~ )�hashrN rO rh rQ rR rS r> r r r r �__hash__� s ��zRSAPrivateNumbers.__hash__r~ )r' r( r) r/ r| r �read_only_propertyrN rO rh rQ rR rS r> r r� r� r� r� r r r r r ? s6 ������ � % r c @ sb e Zd Zdedefdd�Ze�d�Ze�d�Zdde fd d �Z d d � Z d d� Z dd� Z dd� ZdS )r= rW rX c C s, t |t�r t |t�std��|| _|| _d S )Nz,RSAPublicNumbers arguments must be integers.)rE r/ rt �_e�_n)r rW rX r r r r| � s zRSAPublicNumbers.__init__r� r� Nr c C r} r~ )r �load_rsa_public_numbersr� r r r r � r� zRSAPublicNumbers.public_keyc C s d� | �S )Nz$<RSAPublicNumbers(e={0.e}, n={0.n})>)r# r r r r �__repr__� r� zRSAPublicNumbers.__repr__c C s& t |t�stS | j|jko| j|jkS r~ )rE r= r� rW rX r� r r r r� � s zRSAPublicNumbers.__eq__c C r� r~ r r� r r r r� � r� zRSAPublicNumbers.__ne__c C s t | j| jf�S r~ )r� rW rX r r r r r� � s zRSAPublicNumbers.__hash__r~ )r' r( r) r/ r| r r� rW rX r r r� r� r� r� r r r r r= � s r= r~ )*r* r0 �mathr � cryptographyr �cryptography.exceptionsr r � cryptography.hazmat.backendsr �'cryptography.hazmat.backends.interfacesr � cryptography.hazmat.primitivesr r �*cryptography.hazmat.primitives._asymmetricr �)cryptography.hazmat.primitives.asymmetricr r r2 �ABCMetar � RSAPrivateKeyWithSerializationr � RSAPublicKeyWithSerializationr/ rJ rG rV rY rb rc re rg rk �Tuplers �objectr r= r r r r �<module> sv 8@��� � �������� �/ ��� �-Q __pycache__/ec.cpython-310.pyc 0000644 00000036114 15030211711 0012040 0 ustar 00 o �)%a9 � @ s� U d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl m Z m Z d dl m Z mZmZ G dd� de�ZG d d � d e jd �ZG d d � d e jd �ZG dd� de jd �ZeZG dd� de jd �ZeZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z G dd� de�Z G d d � d e�Z G d d � d e�Z G d d!� d!e�Z G d"d#� d#e�Z!G d$d%� d%e�Z"G d&d'� d'e�Z#G d(d)� d)e�Z$G d*d+� d+e�Z%G d,d-� d-e�Z&G d.d/� d/e�Z'G d0d1� d1e�Z(G d2d3� d3e�Z)G d4d5� d5e�Z*G d6d7� d7e�Z+i d8e(�d9e%�d:e(�d;e'�d<e%�d=e$�d>e#�d?e&�d@e"�dAe!�dBe �dCe �dDe �dEe �dFe �dGe�dHe�ee)e*e+dI��Z,ej-e.ej/e f e0dJ< G dKdL� dLe�Z1 d]dMedNefdOdP�Z2 d]dQe3dMedNefdRdS�Z4G dTdU� dUe�Z5G dVdW� dWe�Z6G dXdY� dYe�Z7i ej(e(�ej'e'�ej&e&�ej%e%�ej$e$�ej#e#�ej8e)�ej9e*�ej:e+�ej"e"�ej e �ej!e!�ej e �ej e �eje�ej e �eje�ej e ejei�Z;dZedNej/e fd[d\�Z<dS )^� N)�utils)�ObjectIdentifier)� _get_backend)�_serialization�hashes)�AsymmetricSignatureContext� AsymmetricVerificationContextr c @ s� e Zd Zed�Zed�Zed�Zed�Zed�Zed�Z ed�Z ed�Z ed �Z ed �Z ed �Zed �Zed �Zed�Zed�Zed�Zed�Zed�Zed�ZdS )�EllipticCurveOIDz1.2.840.10045.3.1.1z 1.3.132.0.33z 1.3.132.0.10z1.2.840.10045.3.1.7z 1.3.132.0.34z 1.3.132.0.35z1.3.36.3.3.2.8.1.1.7z1.3.36.3.3.2.8.1.1.11z1.3.36.3.3.2.8.1.1.13z 1.3.132.0.1z 1.3.132.0.15z 1.3.132.0.26z 1.3.132.0.27z 1.3.132.0.16z 1.3.132.0.17z 1.3.132.0.36z 1.3.132.0.37z 1.3.132.0.38z 1.3.132.0.39N)�__name__� __module__� __qualname__r � SECP192R1� SECP224R1� SECP256K1� SECP256R1� SECP384R1� SECP521R1�BRAINPOOLP256R1�BRAINPOOLP384R1�BRAINPOOLP512R1� SECT163K1� SECT163R2� SECT233K1� SECT233R1� SECT283K1� SECT283R1� SECT409K1� SECT409R1� SECT571K1� SECT571R1� r r �N/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/ec.pyr s( r c @ s4 e Zd Zejdefdd��Zejdefdd��ZdS )� EllipticCurve�returnc C � dS )z8 The name of the curve. e.g. secp256r1. Nr ��selfr r r! �name, � zEllipticCurve.namec C r$ �z< Bit size of a secret scalar for the curve. Nr r% r r r! �key_size2 r( zEllipticCurve.key_sizeN) r r r �abc�abstractproperty�strr' �intr* r r r r! r" + s r" )� metaclassc @ s. e Zd Zejdejeje j f fdd��Z dS )� EllipticCurveSignatureAlgorithmr# c C r$ )z@ The digest algorithm used with this signature. Nr r% r r r! � algorithm: r( z)EllipticCurveSignatureAlgorithm.algorithmN) r r r r+ r, �typing�Union� asym_utils� Prehashedr � HashAlgorithmr1 r r r r! r0 9 s �r0 c @ s� e Zd Zejdedefdd��Zejdddddefd d ��Z ejd d d ��Z ej de fd d��Z ej defdd��Zejdedefdd��Zejd dd��Zejdejdejdejdefdd��ZdS ) �EllipticCurvePrivateKey�signature_algorithmr# c C r$ )zN Returns an AsymmetricSignatureContext used for signing data. Nr )r& r8 r r r! �signerD r( z EllipticCurvePrivateKey.signerr1 �ECDH�peer_public_key�EllipticCurvePublicKeyc C r$ )z} Performs a key exchange operation using the provided algorithm with the provided peer's public key. Nr )r& r1 r; r r r! �exchangeM r( z EllipticCurvePrivateKey.exchangec C r$ )zB The EllipticCurvePublicKey for this private key. Nr r% r r r! � public_keyV r( z"EllipticCurvePrivateKey.public_keyc C r$ �z8 The EllipticCurve that this key is on. Nr r% r r r! �curve\ r( z EllipticCurvePrivateKey.curvec C r$ r) r r% r r r! r* b r( z EllipticCurvePrivateKey.key_sizec C r$ )z Signs the data Nr )r& �datar8 r r r! �signh r( z EllipticCurvePrivateKey.sign�EllipticCurvePrivateNumbersc C r$ )z9 Returns an EllipticCurvePrivateNumbers. Nr r% r r r! �private_numbersr r( z'EllipticCurvePrivateKey.private_numbers�encoding�format�encryption_algorithmc C r$ �z6 Returns the key serialized as bytes. Nr )r& rE rF rG r r r! � private_bytesx r( z%EllipticCurvePrivateKey.private_bytesN)r# r< )r# rC )r r r r+ �abstractmethodr0 r r9 �bytesr= r> r, r" r@ r. r* rB rD r �Encoding� PrivateFormat�KeySerializationEncryptionrI r r r r! r7 C sN � ��� � � � ����r7 c @ s� e Zd Zejdededefdd��Zej de fdd��Z ej de fdd ��Z ejdd d ��Zejd ejdejdefdd��Zejdedededdfdd��Zede dedd fdd��ZdS )r< � signaturer8 r# c C r$ )zQ Returns an AsymmetricVerificationContext used for signing data. Nr )r& rO r8 r r r! �verifier� r( z EllipticCurvePublicKey.verifierc C r$ r? r r% r r r! r@ � r( z EllipticCurvePublicKey.curvec C r$ r) r r% r r r! r* � r( z EllipticCurvePublicKey.key_size�EllipticCurvePublicNumbersc C r$ )z8 Returns an EllipticCurvePublicNumbers. Nr r% r r r! �public_numbers� r( z%EllipticCurvePublicKey.public_numbersrE rF c C r$ rH r )r& rE rF r r r! � public_bytes� r( z#EllipticCurvePublicKey.public_bytesrA Nc C r$ )z5 Verifies the signature of the data. Nr )r& rO rA r8 r r r! �verify� r( z EllipticCurvePublicKey.verifyr@ c C s^ t �d|� t|t�std��t|�dkrtd��|d dvr#td��ddlm} |� ||�S )NrA �'curve must be an EllipticCurve instancer z%data must not be an empty byte string)� � � �%Unsupported elliptic curve point type)�backend) r � _check_bytes� isinstancer" � TypeError�len� ValueError�,cryptography.hazmat.backends.openssl.backendrZ � load_elliptic_curve_public_bytes)�clsr@ rA rZ r r r! �from_encoded_point� s z)EllipticCurvePublicKey.from_encoded_point)r# rQ )r r r r+ rJ rK r0 r rP r, r" r@ r. r* rR r rL � PublicFormatrS rT � classmethodrc r r r r! r< � sR �� � �� � ��� � ���r< c @ � e Zd ZdZdZdS )r � sect571r1i: N�r r r r' r* r r r r! r � � r c @ rf )r � sect409r1� Nrh r r r r! r � ri r c @ rf )r � sect283r1� Nrh r r r r! r � ri r c @ rf )r � sect233r1�� Nrh r r r r! r � ri r c @ rf )r � sect163r2� Nrh r r r r! r � ri r c @ rf )r � sect571k1i; Nrh r r r r! r � ri r c @ rf )r � sect409k1rk Nrh r r r r! r � ri r c @ rf )r � sect283k1rm Nrh r r r r! r � ri r c @ rf )r � sect233k1ro Nrh r r r r! r � ri r c @ rf )r � sect163k1rq Nrh r r r r! r � ri r c @ rf )r � secp521r1i Nrh r r r r! r ri r c @ rf )r � secp384r1� Nrh r r r r! r ri r c @ rf )r � secp256r1� Nrh r r r r! r ri r c @ rf )r � secp256k1r{ Nrh r r r r! r ri r c @ rf )r � secp224r1�� Nrh r r r r! r ri r c @ rf )r � secp192r1� Nrh r r r r! r ri r c @ rf )�BrainpoolP256R1�brainpoolP256r1r{ Nrh r r r r! r� ri r� c @ rf )�BrainpoolP384R1�brainpoolP384r1ry Nrh r r r r! r� % ri r� c @ rf )�BrainpoolP512R1�brainpoolP512r1i Nrh r r r r! r� * ri r� � prime192v1� prime256v1r r} rz rx rw r| rv ru rt rs rr rp rn rl rj )rg r� r� r� � _CURVE_TYPESc @ s e Zd Zdd� Ze�d�ZdS )�ECDSAc C s || _ d S �N)� _algorithm)r& r1 r r r! �__init__I � zECDSA.__init__r� N)r r r r� r �read_only_propertyr1 r r r r! r� H s r� r@ r# c C � t |�}|�| �S r� )r �#generate_elliptic_curve_private_key)r@ rZ r r r! �generate_private_keyO s r� � private_valuec C sH t |�}t| t�s td��| dkrtd��t|t�s td��|�| |�S )Nz&private_value must be an integer type.r z)private_value must be a positive integer.�/curve must provide the EllipticCurve interface.)r r\ r. r] r_ r" �!derive_elliptic_curve_private_key)r� r@ rZ r r r! �derive_private_keyV s r� c @ s� e Zd Zdededefdd�Zddefdd �Zdefd d �Z e ded edd fd d��Z e � d�Ze � d�Ze � d�Zdd� Zdd� Zdd� Zdd� ZdS )rQ �x�yr@ c C sD t |t�r t |t�std��t |t�std��|| _|| _|| _d S )Nzx and y must be integers.r� )r\ r. r] r" �_y�_x�_curve)r& r� r� r@ r r r! r� g s z#EllipticCurvePublicNumbers.__init__Nr# c C r� r� )r �"load_elliptic_curve_public_numbers�r& rZ r r r! r> r � z%EllipticCurvePublicNumbers.public_keyc C sB t jdtjdd� | jjd d }dt�| j|� t�| j|� S )Nz�encode_point has been deprecated on EllipticCurvePublicNumbers and will be removed in a future version. Please use EllipticCurvePublicKey.public_bytes to obtain both compressed and uncompressed point encoding.rV �� stacklevel� � � ) �warnings�warnr �PersistentlyDeprecated2019r@ r* � int_to_bytesr� r� )r& � byte_lengthr r r! � encode_pointv s � � ��z'EllipticCurvePublicNumbers.encode_pointrA c C s� t |t�s td��tjdtjdd� |�d�rJ|jd d }t |�d| d krFt � |d|d � d �}t � ||d d � d �}| |||�S t d ��t d ��) NrU z�Support for unsafe construction of public numbers from encoded data will be removed in a future version. Please use EllipticCurvePublicKey.from_encoded_pointrV r� r� r� r� � �bigz(Invalid elliptic curve point data lengthrY ) r\ r" r] r� r� r r� � startswithr* r^ r. � from_bytesr_ )rb r@ rA r� r� r� r r r! rc � s � z-EllipticCurvePublicNumbers.from_encoded_pointr� r� r� c C sF t |t�stS | j|jko"| j|jko"| jj|jjko"| jj|jjkS r� )r\ rQ �NotImplementedr� r� r@ r' r* �r& �otherr r r! �__eq__� s ���z!EllipticCurvePublicNumbers.__eq__c C � | |k S r� r r� r r r! �__ne__� r� z!EllipticCurvePublicNumbers.__ne__c C s t | j| j| jj| jjf�S r� )�hashr� r� r@ r' r* r% r r r! �__hash__� s z#EllipticCurvePublicNumbers.__hash__c C s d� | �S )NzC<EllipticCurvePublicNumbers(curve={0.curve.name}, x={0.x}, y={0.y}>)rF r% r r r! �__repr__� s �z#EllipticCurvePublicNumbers.__repr__r� )r r r r. r" r� r< r> rK r� re rc r r� r@ r� r� r� r� r� r� r r r r! rQ f s& �� � rQ c @ sZ e Zd Zdedefdd�Zddefdd�Ze� d �Z e� d �Z d d � Z d d� Z dd� ZdS )rC r� rR c C s4 t |t�s td��t |t�std��|| _|| _d S )Nz!private_value must be an integer.z>public_numbers must be an EllipticCurvePublicNumbers instance.)r\ r. r] rQ �_private_value�_public_numbers)r& r� rR r r r! r� � s � z$EllipticCurvePrivateNumbers.__init__Nr# c C r� r� )r �#load_elliptic_curve_private_numbersr� r r r! � private_key� r� z'EllipticCurvePrivateNumbers.private_keyr� r� c C s& t |t�stS | j|jko| j|jkS r� )r\ rC r� r� rR r� r r r! r� � s �z"EllipticCurvePrivateNumbers.__eq__c C r� r� r r� r r r! r� � r� z"EllipticCurvePrivateNumbers.__ne__c C s t | j| jf�S r� )r� r� rR r% r r r! r� � s z$EllipticCurvePrivateNumbers.__hash__r� )r r r r. rQ r� r7 r� r r� r� rR r� r� r� r r r r! rC � s � � rC c @ s e Zd ZdS )r: N)r r r r r r r! r: � s r: �oidc C s" zt | W S ty td��w )NzCThe provided object identifier has no matching elliptic curve class)� _OID_TO_CURVE�KeyError� LookupError)r� r r r! �get_curve_for_oid s ��r� r� )=r+ r2 r� � cryptographyr �cryptography.hazmat._oidr � cryptography.hazmat.backendsr � cryptography.hazmat.primitivesr r �)cryptography.hazmat.primitives.asymmetricr r r4 �objectr �ABCMetar" r0 r7 �(EllipticCurvePrivateKeyWithSerializationr< �'EllipticCurvePublicKeyWithSerializationr r r r r r r r r r r r r r r r r� r� r� r� �Dictr- �Type�__annotations__r� r� r. r� rQ rC r: r r r r� r� r r r r! �<module> s AF�������� � � � � ����� ��� ���� �X'�������� � � � � ������ __pycache__/ed448.cpython-310.pyc 0000644 00000005426 15030211711 0012303 0 ustar 00 o �)%aF � @ sP d dl Z d dlmZmZ d dlmZ G dd� de jd�ZG dd� de jd�ZdS ) � N)�UnsupportedAlgorithm�_Reasons)�_serializationc @ sZ e Zd Zededd fdd��Zejdej dej defdd��Z ejd edefd d ��Z d S ) �Ed448PublicKey�data�returnc C �* ddl m} |�� stdtj��|�|�S �Nr )�backendz2ed448 is not supported by this version of OpenSSL.)�,cryptography.hazmat.backends.openssl.backendr �ed448_supportedr r � UNSUPPORTED_PUBLIC_KEY_ALGORITHM�ed448_load_public_bytes��clsr r � r �Q/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/ed448.py�from_public_bytes � � z Ed448PublicKey.from_public_bytes�encoding�formatc C � dS )z9 The serialized bytes of the public key. Nr )�selfr r r r r � public_bytes � zEd448PublicKey.public_bytes� signaturec C r )z' Verify the signature. Nr )r r r r r r �verify# r zEd448PublicKey.verifyN) �__name__� __module__� __qualname__� classmethod�bytesr �abc�abstractmethodr �Encoding� PublicFormatr r r r r r r s �� � r )� metaclassc @ s~ e Zd Zeddd��Zededd fdd��Zejde fdd��Z ejdedefd d ��Z ejd e j d e jd e jfdd��ZdS )�Ed448PrivateKeyr c C s( ddl m} |�� stdtj��|�� S r )r r r r r r �ed448_generate_key)r r r r r �generate+ s �zEd448PrivateKey.generater c C r r )r r r r r r �ed448_load_private_bytesr r r r �from_private_bytes6 r z"Ed448PrivateKey.from_private_bytesc C r )zB The Ed448PublicKey derived from the private key. Nr )r r r r � public_keyB r zEd448PrivateKey.public_keyc C r )z! Signs the data. Nr )r r r r r �signH r zEd448PrivateKey.signr r �encryption_algorithmc C r )z: The serialized bytes of the private key. Nr )r r r r. r r r � private_bytesN r z Ed448PrivateKey.private_bytesN)r r' )r r r r r) r! r+ r" r# r r, r- r r$ � PrivateFormat�KeySerializationEncryptionr/ r r r r r' * s" ���r' ) r" �cryptography.exceptionsr r � cryptography.hazmat.primitivesr �ABCMetar r' r r r r �<module> s __pycache__/dh.cpython-310.pyc 0000644 00000016205 15030211711 0012043 0 ustar 00 o �)%a� � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZ dZdddd �Z G d d � d e �Z G d d � d e �Z G dd� de �Z G dd� de jd�ZeZG dd� de jd�ZeZG dd� de jd�ZeZdS )� N)�utils)� _get_backend)� serializationi �return� DHParametersc C s t |�}|�| |�S �N)r �generate_dh_parameters)� generator�key_size�backend� r �N/usr/lib/python3/dist-packages/cryptography/hazmat/primitives/asymmetric/dh.py�generate_parameters s r c @ sb e Zd Zddededeje fdd�Zdd� Zd d � Zdd d �Z e � d �Z e � d�Z e � d�ZdS )�DHParameterNumbersN�p�g�qc C sv t |t�r t |t�std��|d urt |t�std��|dk r#td��|�� tk r0td�t���|| _|| _|| _ d S )Nzp and g must be integerszq must be integer or None� z!DH generator must be 2 or greaterz#p (modulus) must be at least {}-bit) � isinstance�int� TypeError� ValueError� bit_length�_MIN_MODULUS_SIZE�format�_p�_g�_q)�selfr r r r r r �__init__ s � zDHParameterNumbers.__init__c C s2 t |t�stS | j|jko| j|jko| j|jkS r )r r �NotImplementedr r r �r �otherr r r �__eq__) s "�zDHParameterNumbers.__eq__c C � | |k S r r r! r r r �__ne__1 � zDHParameterNumbers.__ne__c C � t |�}|�| �S r )r �load_dh_parameter_numbers�r r r r r � parameters4 � z DHParameterNumbers.parametersr r r r )�__name__� __module__� __qualname__r �typing�Optionalr r# r% r* r �read_only_propertyr r r r r r r r s r c @ �J e Zd Zdefdd�Zdd� Zdd� Zddd d �Ze� d �Z e� d�Z dS )�DHPublicNumbers�parameter_numbersc C �4 t |t�s td��t |t�std��|| _|| _d S )Nzy must be an integer.z5parameters must be an instance of DHParameterNumbers.)r r r r �_y�_parameter_numbers)r �yr4 r r r r > � � zDHPublicNumbers.__init__c C �& t |t�stS | j|jko| j|jkS r )r r3 r r6 r7 r! r r r r# J � �zDHPublicNumbers.__eq__c C r$ r r r! r r r r% S r& zDHPublicNumbers.__ne__Nr � DHPublicKeyc C r' r )r �load_dh_public_numbersr) r r r � public_keyV r+ zDHPublicNumbers.public_keyr6 r7 r )r r< ) r, r- r. r r r# r% r> r r1 r8 r4 r r r r r3 = � r3 c @ r2 )�DHPrivateNumbers�public_numbersc C r5 )Nzx must be an integer.z6public_numbers must be an instance of DHPublicNumbers.)r r r r3 �_x�_public_numbers)r �xrA r r r r _ r9 zDHPrivateNumbers.__init__c C r: r )r r@ r rB rC r! r r r r# k r; zDHPrivateNumbers.__eq__c C r$ r r r! r r r r% t r& zDHPrivateNumbers.__ne__Nr � DHPrivateKeyc C r' r )r �load_dh_private_numbersr) r r r � private_keyw r+ z DHPrivateNumbers.private_keyrC rB r �r rE ) r, r- r. r3 r r# r% rG r r1 rA rD r r r r r@ ^ r? r@ c @ sL e Zd Zejddd��Zejdddddefd d ��Zejdefd d ��Z d S )r r rE c C � dS )z7 Generates and returns a DHPrivateKey. Nr �r r r r �generate_private_key� � z!DHParameters.generate_private_key�encoding�serialization.Encodingr z serialization.ParameterFormatc C rI )z= Returns the parameters serialized as bytes. Nr �r rM r r r r �parameter_bytes� rL z DHParameters.parameter_bytesc C rI )z/ Returns a DHParameterNumbers. Nr rJ r r r r4 � rL z DHParameters.parameter_numbersNrH ) r, r- r. �abc�abstractmethodrK �bytesrP r r4 r r r r r s �� � )� metaclassc @ sd e Zd Zejdefdd��Zejdefdd��Z ejde fdd��Z ejdd d d de fd d ��Z dS )r< r c C rI �z6 The bit length of the prime modulus. Nr rJ r r r r � rL zDHPublicKey.key_sizec C rI )zJ The DHParameters object associated with this public key. Nr rJ r r r r* � rL zDHPublicKey.parametersc C rI )z, Returns a DHPublicNumbers. Nr rJ r r r rA � rL zDHPublicKey.public_numbersrM rN r zserialization.PublicFormatc C rI �z6 Returns the key serialized as bytes. Nr rO r r r � public_bytes� rL zDHPublicKey.public_bytesN)r, r- r. rQ �abstractpropertyr r rR r r* r3 rA rS rW r r r r r< � s ���r< c @ s� e Zd Zejdefdd��Zejdefdd��Z ejde fdd��Z ejdede fd d ��Z ejdefd d ��Zejd dddddde fdd��ZdS )rE r c C rI rU r rJ r r r r � rL zDHPrivateKey.key_sizec C rI )zC The DHPublicKey associated with this private key. Nr rJ r r r r> � rL zDHPrivateKey.public_keyc C rI )zK The DHParameters object associated with this private key. Nr rJ r r r r* � rL zDHPrivateKey.parameters�peer_public_keyc C rI )zn Given peer's DHPublicKey, carry out the key exchange and return shared key as bytes. Nr )r rY r r r �exchange� rL zDHPrivateKey.exchangec C rI )z- Returns a DHPrivateNumbers. Nr rJ r r r �private_numbers� rL z DHPrivateKey.private_numbersrM rN r zserialization.PrivateFormat�encryption_algorithmz(serialization.KeySerializationEncryptionc C rI rV r )r rM r r\ r r r � private_bytes� rL zDHPrivateKey.private_bytesN)r, r- r. rQ rX r r rR r< r> r r* rS rZ r@ r[ r] r r r r rE � s* ����rE r )r r )rQ r/ � cryptographyr � cryptography.hazmat.backendsr � cryptography.hazmat.primitivesr r r �objectr r3 r@ �ABCMetar � DHParametersWithSerializationr< � DHPublicKeyWithSerializationrE � DHPrivateKeyWithSerializationr r r r �<module> s '!! , dsa.py 0000644 00000017664 15030211711 0005672 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import typing from cryptography import utils from cryptography.hazmat.backends import _get_backend from cryptography.hazmat.primitives import _serialization, hashes from cryptography.hazmat.primitives.asymmetric import ( AsymmetricSignatureContext, AsymmetricVerificationContext, utils as asym_utils, ) class DSAParameters(metaclass=abc.ABCMeta): @abc.abstractmethod def generate_private_key(self) -> "DSAPrivateKey": """ Generates and returns a DSAPrivateKey. """ @abc.abstractmethod def parameter_numbers(self) -> "DSAParameterNumbers": """ Returns a DSAParameterNumbers. """ DSAParametersWithNumbers = DSAParameters class DSAPrivateKey(metaclass=abc.ABCMeta): @abc.abstractproperty def key_size(self) -> int: """ The bit length of the prime modulus. """ @abc.abstractmethod def public_key(self) -> "DSAPublicKey": """ The DSAPublicKey associated with this private key. """ @abc.abstractmethod def parameters(self) -> DSAParameters: """ The DSAParameters object associated with this private key. """ @abc.abstractmethod def signer( self, signature_algorithm: hashes.HashAlgorithm, ) -> AsymmetricSignatureContext: """ Returns an AsymmetricSignatureContext used for signing data. """ @abc.abstractmethod def sign( self, data: bytes, algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm], ) -> bytes: """ Signs the data """ @abc.abstractmethod def private_numbers(self) -> "DSAPrivateNumbers": """ Returns a DSAPrivateNumbers. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ) -> bytes: """ Returns the key serialized as bytes. """ DSAPrivateKeyWithSerialization = DSAPrivateKey class DSAPublicKey(metaclass=abc.ABCMeta): @abc.abstractproperty def key_size(self) -> int: """ The bit length of the prime modulus. """ @abc.abstractmethod def parameters(self) -> DSAParameters: """ The DSAParameters object associated with this public key. """ @abc.abstractmethod def verifier( self, signature: bytes, signature_algorithm: hashes.HashAlgorithm, ) -> AsymmetricVerificationContext: """ Returns an AsymmetricVerificationContext used for signing data. """ @abc.abstractmethod def public_numbers(self) -> "DSAPublicNumbers": """ Returns a DSAPublicNumbers. """ @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ Returns the key serialized as bytes. """ @abc.abstractmethod def verify( self, signature: bytes, data: bytes, algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm], ): """ Verifies the signature of the data. """ DSAPublicKeyWithSerialization = DSAPublicKey class DSAParameterNumbers(object): def __init__(self, p: int, q: int, g: int): if ( not isinstance(p, int) or not isinstance(q, int) or not isinstance(g, int) ): raise TypeError( "DSAParameterNumbers p, q, and g arguments must be integers." ) self._p = p self._q = q self._g = g p = utils.read_only_property("_p") q = utils.read_only_property("_q") g = utils.read_only_property("_g") def parameters(self, backend=None) -> DSAParameters: backend = _get_backend(backend) return backend.load_dsa_parameter_numbers(self) def __eq__(self, other): if not isinstance(other, DSAParameterNumbers): return NotImplemented return self.p == other.p and self.q == other.q and self.g == other.g def __ne__(self, other): return not self == other def __repr__(self): return ( "<DSAParameterNumbers(p={self.p}, q={self.q}, " "g={self.g})>".format(self=self) ) class DSAPublicNumbers(object): def __init__(self, y: int, parameter_numbers: DSAParameterNumbers): if not isinstance(y, int): raise TypeError("DSAPublicNumbers y argument must be an integer.") if not isinstance(parameter_numbers, DSAParameterNumbers): raise TypeError( "parameter_numbers must be a DSAParameterNumbers instance." ) self._y = y self._parameter_numbers = parameter_numbers y = utils.read_only_property("_y") parameter_numbers = utils.read_only_property("_parameter_numbers") def public_key(self, backend=None) -> DSAPublicKey: backend = _get_backend(backend) return backend.load_dsa_public_numbers(self) def __eq__(self, other): if not isinstance(other, DSAPublicNumbers): return NotImplemented return ( self.y == other.y and self.parameter_numbers == other.parameter_numbers ) def __ne__(self, other): return not self == other def __repr__(self): return ( "<DSAPublicNumbers(y={self.y}, " "parameter_numbers={self.parameter_numbers})>".format(self=self) ) class DSAPrivateNumbers(object): def __init__(self, x: int, public_numbers: DSAPublicNumbers): if not isinstance(x, int): raise TypeError("DSAPrivateNumbers x argument must be an integer.") if not isinstance(public_numbers, DSAPublicNumbers): raise TypeError( "public_numbers must be a DSAPublicNumbers instance." ) self._public_numbers = public_numbers self._x = x x = utils.read_only_property("_x") public_numbers = utils.read_only_property("_public_numbers") def private_key(self, backend=None) -> DSAPrivateKey: backend = _get_backend(backend) return backend.load_dsa_private_numbers(self) def __eq__(self, other): if not isinstance(other, DSAPrivateNumbers): return NotImplemented return ( self.x == other.x and self.public_numbers == other.public_numbers ) def __ne__(self, other): return not self == other def generate_parameters(key_size: int, backend=None) -> DSAParameters: backend = _get_backend(backend) return backend.generate_dsa_parameters(key_size) def generate_private_key(key_size: int, backend=None) -> DSAPrivateKey: backend = _get_backend(backend) return backend.generate_dsa_private_key_and_parameters(key_size) def _check_dsa_parameters(parameters: DSAParameterNumbers): if parameters.p.bit_length() not in [1024, 2048, 3072, 4096]: raise ValueError( "p must be exactly 1024, 2048, 3072, or 4096 bits long" ) if parameters.q.bit_length() not in [160, 224, 256]: raise ValueError("q must be exactly 160, 224, or 256 bits long") if not (1 < parameters.g < parameters.p): raise ValueError("g, p don't satisfy 1 < g < p.") def _check_dsa_private_numbers(numbers: DSAPrivateNumbers): parameters = numbers.public_numbers.parameter_numbers _check_dsa_parameters(parameters) if numbers.x <= 0 or numbers.x >= parameters.q: raise ValueError("x must be > 0 and < q.") if numbers.public_numbers.y != pow(parameters.g, numbers.x, parameters.p): raise ValueError("y must be equal to (g ** x % p).") padding.py 0000644 00000004103 15030211711 0006511 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import typing from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding from cryptography.hazmat.primitives.asymmetric import rsa class PKCS1v15(AsymmetricPadding): name = "EMSA-PKCS1-v1_5" class PSS(AsymmetricPadding): MAX_LENGTH = object() name = "EMSA-PSS" def __init__(self, mgf, salt_length): self._mgf = mgf if ( not isinstance(salt_length, int) and salt_length is not self.MAX_LENGTH ): raise TypeError("salt_length must be an integer.") if salt_length is not self.MAX_LENGTH and salt_length < 0: raise ValueError("salt_length must be zero or greater.") self._salt_length = salt_length class OAEP(AsymmetricPadding): name = "EME-OAEP" def __init__( self, mgf: "MGF1", algorithm: hashes.HashAlgorithm, label: typing.Optional[bytes], ): if not isinstance(algorithm, hashes.HashAlgorithm): raise TypeError("Expected instance of hashes.HashAlgorithm.") self._mgf = mgf self._algorithm = algorithm self._label = label class MGF1(object): MAX_LENGTH = object() def __init__(self, algorithm: hashes.HashAlgorithm): if not isinstance(algorithm, hashes.HashAlgorithm): raise TypeError("Expected instance of hashes.HashAlgorithm.") self._algorithm = algorithm def calculate_max_pss_salt_length( key: typing.Union["rsa.RSAPrivateKey", "rsa.RSAPublicKey"], hash_algorithm: hashes.HashAlgorithm, ) -> int: if not isinstance(key, (rsa.RSAPrivateKey, rsa.RSAPublicKey)): raise TypeError("key must be an RSA public or private key") # bit length - 1 per RFC 3447 emlen = (key.key_size + 6) // 8 salt_length = emlen - hash_algorithm.digest_size - 2 assert salt_length >= 0 return salt_length rsa.py 0000644 00000027344 15030211711 0005704 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import typing from math import gcd from cryptography import utils from cryptography.exceptions import UnsupportedAlgorithm, _Reasons from cryptography.hazmat.backends import _get_backend from cryptography.hazmat.backends.interfaces import RSABackend from cryptography.hazmat.primitives import _serialization, hashes from cryptography.hazmat.primitives._asymmetric import AsymmetricPadding from cryptography.hazmat.primitives.asymmetric import ( AsymmetricSignatureContext, AsymmetricVerificationContext, utils as asym_utils, ) class RSAPrivateKey(metaclass=abc.ABCMeta): @abc.abstractmethod def signer( self, padding: AsymmetricPadding, algorithm: hashes.HashAlgorithm ) -> AsymmetricSignatureContext: """ Returns an AsymmetricSignatureContext used for signing data. """ @abc.abstractmethod def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes: """ Decrypts the provided ciphertext. """ @abc.abstractproperty def key_size(self) -> int: """ The bit length of the public modulus. """ @abc.abstractmethod def public_key(self) -> "RSAPublicKey": """ The RSAPublicKey associated with this private key. """ @abc.abstractmethod def sign( self, data: bytes, padding: AsymmetricPadding, algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm], ) -> bytes: """ Signs the data. """ @abc.abstractmethod def private_numbers(self) -> "RSAPrivateNumbers": """ Returns an RSAPrivateNumbers. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ) -> bytes: """ Returns the key serialized as bytes. """ RSAPrivateKeyWithSerialization = RSAPrivateKey class RSAPublicKey(metaclass=abc.ABCMeta): @abc.abstractmethod def verifier( self, signature: bytes, padding: AsymmetricPadding, algorithm: hashes.HashAlgorithm, ) -> AsymmetricVerificationContext: """ Returns an AsymmetricVerificationContext used for verifying signatures. """ @abc.abstractmethod def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes: """ Encrypts the given plaintext. """ @abc.abstractproperty def key_size(self) -> int: """ The bit length of the public modulus. """ @abc.abstractmethod def public_numbers(self) -> "RSAPublicNumbers": """ Returns an RSAPublicNumbers """ @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ Returns the key serialized as bytes. """ @abc.abstractmethod def verify( self, signature: bytes, data: bytes, padding: AsymmetricPadding, algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm], ) -> None: """ Verifies the signature of the data. """ @abc.abstractmethod def recover_data_from_signature( self, signature: bytes, padding: AsymmetricPadding, algorithm: typing.Optional[hashes.HashAlgorithm], ) -> bytes: """ Recovers the original data from the signature. """ RSAPublicKeyWithSerialization = RSAPublicKey def generate_private_key( public_exponent: int, key_size: int, backend=None ) -> RSAPrivateKey: backend = _get_backend(backend) if not isinstance(backend, RSABackend): raise UnsupportedAlgorithm( "Backend object does not implement RSABackend.", _Reasons.BACKEND_MISSING_INTERFACE, ) _verify_rsa_parameters(public_exponent, key_size) return backend.generate_rsa_private_key(public_exponent, key_size) def _verify_rsa_parameters(public_exponent: int, key_size: int) -> None: if public_exponent not in (3, 65537): raise ValueError( "public_exponent must be either 3 (for legacy compatibility) or " "65537. Almost everyone should choose 65537 here!" ) if key_size < 512: raise ValueError("key_size must be at least 512-bits.") def _check_private_key_components( p: int, q: int, private_exponent: int, dmp1: int, dmq1: int, iqmp: int, public_exponent: int, modulus: int, ) -> None: if modulus < 3: raise ValueError("modulus must be >= 3.") if p >= modulus: raise ValueError("p must be < modulus.") if q >= modulus: raise ValueError("q must be < modulus.") if dmp1 >= modulus: raise ValueError("dmp1 must be < modulus.") if dmq1 >= modulus: raise ValueError("dmq1 must be < modulus.") if iqmp >= modulus: raise ValueError("iqmp must be < modulus.") if private_exponent >= modulus: raise ValueError("private_exponent must be < modulus.") if public_exponent < 3 or public_exponent >= modulus: raise ValueError("public_exponent must be >= 3 and < modulus.") if public_exponent & 1 == 0: raise ValueError("public_exponent must be odd.") if dmp1 & 1 == 0: raise ValueError("dmp1 must be odd.") if dmq1 & 1 == 0: raise ValueError("dmq1 must be odd.") if p * q != modulus: raise ValueError("p*q must equal modulus.") def _check_public_key_components(e: int, n: int) -> None: if n < 3: raise ValueError("n must be >= 3.") if e < 3 or e >= n: raise ValueError("e must be >= 3 and < n.") if e & 1 == 0: raise ValueError("e must be odd.") def _modinv(e: int, m: int) -> int: """ Modular Multiplicative Inverse. Returns x such that: (x*e) mod m == 1 """ x1, x2 = 1, 0 a, b = e, m while b > 0: q, r = divmod(a, b) xn = x1 - q * x2 a, b, x1, x2 = b, r, x2, xn return x1 % m def rsa_crt_iqmp(p: int, q: int) -> int: """ Compute the CRT (q ** -1) % p value from RSA primes p and q. """ return _modinv(q, p) def rsa_crt_dmp1(private_exponent: int, p: int) -> int: """ Compute the CRT private_exponent % (p - 1) value from the RSA private_exponent (d) and p. """ return private_exponent % (p - 1) def rsa_crt_dmq1(private_exponent: int, q: int) -> int: """ Compute the CRT private_exponent % (q - 1) value from the RSA private_exponent (d) and q. """ return private_exponent % (q - 1) # Controls the number of iterations rsa_recover_prime_factors will perform # to obtain the prime factors. Each iteration increments by 2 so the actual # maximum attempts is half this number. _MAX_RECOVERY_ATTEMPTS = 1000 def rsa_recover_prime_factors( n: int, e: int, d: int ) -> typing.Tuple[int, int]: """ Compute factors p and q from the private exponent d. We assume that n has no more than two factors. This function is adapted from code in PyCrypto. """ # See 8.2.2(i) in Handbook of Applied Cryptography. ktot = d * e - 1 # The quantity d*e-1 is a multiple of phi(n), even, # and can be represented as t*2^s. t = ktot while t % 2 == 0: t = t // 2 # Cycle through all multiplicative inverses in Zn. # The algorithm is non-deterministic, but there is a 50% chance # any candidate a leads to successful factoring. # See "Digitalized Signatures and Public Key Functions as Intractable # as Factorization", M. Rabin, 1979 spotted = False a = 2 while not spotted and a < _MAX_RECOVERY_ATTEMPTS: k = t # Cycle through all values a^{t*2^i}=a^k while k < ktot: cand = pow(a, k, n) # Check if a^k is a non-trivial root of unity (mod n) if cand != 1 and cand != (n - 1) and pow(cand, 2, n) == 1: # We have found a number such that (cand-1)(cand+1)=0 (mod n). # Either of the terms divides n. p = gcd(cand + 1, n) spotted = True break k *= 2 # This value was not any good... let's try another! a += 2 if not spotted: raise ValueError("Unable to compute factors p and q from exponent d.") # Found ! q, r = divmod(n, p) assert r == 0 p, q = sorted((p, q), reverse=True) return (p, q) class RSAPrivateNumbers(object): def __init__( self, p: int, q: int, d: int, dmp1: int, dmq1: int, iqmp: int, public_numbers: "RSAPublicNumbers", ): if ( not isinstance(p, int) or not isinstance(q, int) or not isinstance(d, int) or not isinstance(dmp1, int) or not isinstance(dmq1, int) or not isinstance(iqmp, int) ): raise TypeError( "RSAPrivateNumbers p, q, d, dmp1, dmq1, iqmp arguments must" " all be an integers." ) if not isinstance(public_numbers, RSAPublicNumbers): raise TypeError( "RSAPrivateNumbers public_numbers must be an RSAPublicNumbers" " instance." ) self._p = p self._q = q self._d = d self._dmp1 = dmp1 self._dmq1 = dmq1 self._iqmp = iqmp self._public_numbers = public_numbers p = utils.read_only_property("_p") q = utils.read_only_property("_q") d = utils.read_only_property("_d") dmp1 = utils.read_only_property("_dmp1") dmq1 = utils.read_only_property("_dmq1") iqmp = utils.read_only_property("_iqmp") public_numbers = utils.read_only_property("_public_numbers") def private_key(self, backend=None) -> RSAPrivateKey: backend = _get_backend(backend) return backend.load_rsa_private_numbers(self) def __eq__(self, other): if not isinstance(other, RSAPrivateNumbers): return NotImplemented return ( self.p == other.p and self.q == other.q and self.d == other.d and self.dmp1 == other.dmp1 and self.dmq1 == other.dmq1 and self.iqmp == other.iqmp and self.public_numbers == other.public_numbers ) def __ne__(self, other): return not self == other def __hash__(self): return hash( ( self.p, self.q, self.d, self.dmp1, self.dmq1, self.iqmp, self.public_numbers, ) ) class RSAPublicNumbers(object): def __init__(self, e: int, n: int): if not isinstance(e, int) or not isinstance(n, int): raise TypeError("RSAPublicNumbers arguments must be integers.") self._e = e self._n = n e = utils.read_only_property("_e") n = utils.read_only_property("_n") def public_key(self, backend=None) -> RSAPublicKey: backend = _get_backend(backend) return backend.load_rsa_public_numbers(self) def __repr__(self): return "<RSAPublicNumbers(e={0.e}, n={0.n})>".format(self) def __eq__(self, other): if not isinstance(other, RSAPublicNumbers): return NotImplemented return self.e == other.e and self.n == other.n def __ne__(self, other): return not self == other def __hash__(self): return hash((self.e, self.n)) x448.py 0000644 00000004765 15030211711 0005630 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc from cryptography.exceptions import UnsupportedAlgorithm, _Reasons from cryptography.hazmat.primitives import _serialization class X448PublicKey(metaclass=abc.ABCMeta): @classmethod def from_public_bytes(cls, data) -> "X448PublicKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x448_supported(): raise UnsupportedAlgorithm( "X448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x448_load_public_bytes(data) @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ The serialized bytes of the public key. """ class X448PrivateKey(metaclass=abc.ABCMeta): @classmethod def generate(cls) -> "X448PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x448_supported(): raise UnsupportedAlgorithm( "X448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x448_generate_key() @classmethod def from_private_bytes(cls, data: bytes) -> "X448PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x448_supported(): raise UnsupportedAlgorithm( "X448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x448_load_private_bytes(data) @abc.abstractmethod def public_key(self) -> X448PublicKey: """ The serialized bytes of the public key. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ) -> bytes: """ The serialized bytes of the private key. """ @abc.abstractmethod def exchange(self, peer_public_key: X448PublicKey) -> bytes: """ Performs a key exchange operation using the provided peer's public key. """ ec.py 0000644 00000034425 15030211711 0005504 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc import typing import warnings from cryptography import utils from cryptography.hazmat._oid import ObjectIdentifier from cryptography.hazmat.backends import _get_backend from cryptography.hazmat.primitives import _serialization, hashes from cryptography.hazmat.primitives.asymmetric import ( AsymmetricSignatureContext, AsymmetricVerificationContext, utils as asym_utils, ) class EllipticCurveOID(object): SECP192R1 = ObjectIdentifier("1.2.840.10045.3.1.1") SECP224R1 = ObjectIdentifier("1.3.132.0.33") SECP256K1 = ObjectIdentifier("1.3.132.0.10") SECP256R1 = ObjectIdentifier("1.2.840.10045.3.1.7") SECP384R1 = ObjectIdentifier("1.3.132.0.34") SECP521R1 = ObjectIdentifier("1.3.132.0.35") BRAINPOOLP256R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.7") BRAINPOOLP384R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.11") BRAINPOOLP512R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.13") SECT163K1 = ObjectIdentifier("1.3.132.0.1") SECT163R2 = ObjectIdentifier("1.3.132.0.15") SECT233K1 = ObjectIdentifier("1.3.132.0.26") SECT233R1 = ObjectIdentifier("1.3.132.0.27") SECT283K1 = ObjectIdentifier("1.3.132.0.16") SECT283R1 = ObjectIdentifier("1.3.132.0.17") SECT409K1 = ObjectIdentifier("1.3.132.0.36") SECT409R1 = ObjectIdentifier("1.3.132.0.37") SECT571K1 = ObjectIdentifier("1.3.132.0.38") SECT571R1 = ObjectIdentifier("1.3.132.0.39") class EllipticCurve(metaclass=abc.ABCMeta): @abc.abstractproperty def name(self) -> str: """ The name of the curve. e.g. secp256r1. """ @abc.abstractproperty def key_size(self) -> int: """ Bit size of a secret scalar for the curve. """ class EllipticCurveSignatureAlgorithm(metaclass=abc.ABCMeta): @abc.abstractproperty def algorithm( self, ) -> typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm]: """ The digest algorithm used with this signature. """ class EllipticCurvePrivateKey(metaclass=abc.ABCMeta): @abc.abstractmethod def signer( self, signature_algorithm: EllipticCurveSignatureAlgorithm, ) -> AsymmetricSignatureContext: """ Returns an AsymmetricSignatureContext used for signing data. """ @abc.abstractmethod def exchange( self, algorithm: "ECDH", peer_public_key: "EllipticCurvePublicKey" ) -> bytes: """ Performs a key exchange operation using the provided algorithm with the provided peer's public key. """ @abc.abstractmethod def public_key(self) -> "EllipticCurvePublicKey": """ The EllipticCurvePublicKey for this private key. """ @abc.abstractproperty def curve(self) -> EllipticCurve: """ The EllipticCurve that this key is on. """ @abc.abstractproperty def key_size(self) -> int: """ Bit size of a secret scalar for the curve. """ @abc.abstractmethod def sign( self, data, signature_algorithm: EllipticCurveSignatureAlgorithm, ) -> bytes: """ Signs the data """ @abc.abstractmethod def private_numbers(self) -> "EllipticCurvePrivateNumbers": """ Returns an EllipticCurvePrivateNumbers. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ) -> bytes: """ Returns the key serialized as bytes. """ EllipticCurvePrivateKeyWithSerialization = EllipticCurvePrivateKey class EllipticCurvePublicKey(metaclass=abc.ABCMeta): @abc.abstractmethod def verifier( self, signature: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm, ) -> AsymmetricVerificationContext: """ Returns an AsymmetricVerificationContext used for signing data. """ @abc.abstractproperty def curve(self) -> EllipticCurve: """ The EllipticCurve that this key is on. """ @abc.abstractproperty def key_size(self) -> int: """ Bit size of a secret scalar for the curve. """ @abc.abstractmethod def public_numbers(self) -> "EllipticCurvePublicNumbers": """ Returns an EllipticCurvePublicNumbers. """ @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ Returns the key serialized as bytes. """ @abc.abstractmethod def verify( self, signature: bytes, data: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm, ) -> None: """ Verifies the signature of the data. """ @classmethod def from_encoded_point( cls, curve: EllipticCurve, data: bytes ) -> "EllipticCurvePublicKey": utils._check_bytes("data", data) if not isinstance(curve, EllipticCurve): raise TypeError("curve must be an EllipticCurve instance") if len(data) == 0: raise ValueError("data must not be an empty byte string") if data[0] not in [0x02, 0x03, 0x04]: raise ValueError("Unsupported elliptic curve point type") from cryptography.hazmat.backends.openssl.backend import backend return backend.load_elliptic_curve_public_bytes(curve, data) EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey class SECT571R1(EllipticCurve): name = "sect571r1" key_size = 570 class SECT409R1(EllipticCurve): name = "sect409r1" key_size = 409 class SECT283R1(EllipticCurve): name = "sect283r1" key_size = 283 class SECT233R1(EllipticCurve): name = "sect233r1" key_size = 233 class SECT163R2(EllipticCurve): name = "sect163r2" key_size = 163 class SECT571K1(EllipticCurve): name = "sect571k1" key_size = 571 class SECT409K1(EllipticCurve): name = "sect409k1" key_size = 409 class SECT283K1(EllipticCurve): name = "sect283k1" key_size = 283 class SECT233K1(EllipticCurve): name = "sect233k1" key_size = 233 class SECT163K1(EllipticCurve): name = "sect163k1" key_size = 163 class SECP521R1(EllipticCurve): name = "secp521r1" key_size = 521 class SECP384R1(EllipticCurve): name = "secp384r1" key_size = 384 class SECP256R1(EllipticCurve): name = "secp256r1" key_size = 256 class SECP256K1(EllipticCurve): name = "secp256k1" key_size = 256 class SECP224R1(EllipticCurve): name = "secp224r1" key_size = 224 class SECP192R1(EllipticCurve): name = "secp192r1" key_size = 192 class BrainpoolP256R1(EllipticCurve): name = "brainpoolP256r1" key_size = 256 class BrainpoolP384R1(EllipticCurve): name = "brainpoolP384r1" key_size = 384 class BrainpoolP512R1(EllipticCurve): name = "brainpoolP512r1" key_size = 512 _CURVE_TYPES: typing.Dict[str, typing.Type[EllipticCurve]] = { "prime192v1": SECP192R1, "prime256v1": SECP256R1, "secp192r1": SECP192R1, "secp224r1": SECP224R1, "secp256r1": SECP256R1, "secp384r1": SECP384R1, "secp521r1": SECP521R1, "secp256k1": SECP256K1, "sect163k1": SECT163K1, "sect233k1": SECT233K1, "sect283k1": SECT283K1, "sect409k1": SECT409K1, "sect571k1": SECT571K1, "sect163r2": SECT163R2, "sect233r1": SECT233R1, "sect283r1": SECT283R1, "sect409r1": SECT409R1, "sect571r1": SECT571R1, "brainpoolP256r1": BrainpoolP256R1, "brainpoolP384r1": BrainpoolP384R1, "brainpoolP512r1": BrainpoolP512R1, } class ECDSA(EllipticCurveSignatureAlgorithm): def __init__(self, algorithm): self._algorithm = algorithm algorithm = utils.read_only_property("_algorithm") def generate_private_key( curve: EllipticCurve, backend=None ) -> EllipticCurvePrivateKey: backend = _get_backend(backend) return backend.generate_elliptic_curve_private_key(curve) def derive_private_key( private_value: int, curve: EllipticCurve, backend=None ) -> EllipticCurvePrivateKey: backend = _get_backend(backend) if not isinstance(private_value, int): raise TypeError("private_value must be an integer type.") if private_value <= 0: raise ValueError("private_value must be a positive integer.") if not isinstance(curve, EllipticCurve): raise TypeError("curve must provide the EllipticCurve interface.") return backend.derive_elliptic_curve_private_key(private_value, curve) class EllipticCurvePublicNumbers(object): def __init__(self, x: int, y: int, curve: EllipticCurve): if not isinstance(x, int) or not isinstance(y, int): raise TypeError("x and y must be integers.") if not isinstance(curve, EllipticCurve): raise TypeError("curve must provide the EllipticCurve interface.") self._y = y self._x = x self._curve = curve def public_key(self, backend=None) -> EllipticCurvePublicKey: backend = _get_backend(backend) return backend.load_elliptic_curve_public_numbers(self) def encode_point(self) -> bytes: warnings.warn( "encode_point has been deprecated on EllipticCurvePublicNumbers" " and will be removed in a future version. Please use " "EllipticCurvePublicKey.public_bytes to obtain both " "compressed and uncompressed point encoding.", utils.PersistentlyDeprecated2019, stacklevel=2, ) # key_size is in bits. Convert to bytes and round up byte_length = (self.curve.key_size + 7) // 8 return ( b"\x04" + utils.int_to_bytes(self.x, byte_length) + utils.int_to_bytes(self.y, byte_length) ) @classmethod def from_encoded_point( cls, curve: EllipticCurve, data: bytes ) -> "EllipticCurvePublicNumbers": if not isinstance(curve, EllipticCurve): raise TypeError("curve must be an EllipticCurve instance") warnings.warn( "Support for unsafe construction of public numbers from " "encoded data will be removed in a future version. " "Please use EllipticCurvePublicKey.from_encoded_point", utils.PersistentlyDeprecated2019, stacklevel=2, ) if data.startswith(b"\x04"): # key_size is in bits. Convert to bytes and round up byte_length = (curve.key_size + 7) // 8 if len(data) == 2 * byte_length + 1: x = int.from_bytes(data[1 : byte_length + 1], "big") y = int.from_bytes(data[byte_length + 1 :], "big") return cls(x, y, curve) else: raise ValueError("Invalid elliptic curve point data length") else: raise ValueError("Unsupported elliptic curve point type") curve = utils.read_only_property("_curve") x = utils.read_only_property("_x") y = utils.read_only_property("_y") def __eq__(self, other): if not isinstance(other, EllipticCurvePublicNumbers): return NotImplemented return ( self.x == other.x and self.y == other.y and self.curve.name == other.curve.name and self.curve.key_size == other.curve.key_size ) def __ne__(self, other): return not self == other def __hash__(self): return hash((self.x, self.y, self.curve.name, self.curve.key_size)) def __repr__(self): return ( "<EllipticCurvePublicNumbers(curve={0.curve.name}, x={0.x}, " "y={0.y}>".format(self) ) class EllipticCurvePrivateNumbers(object): def __init__( self, private_value: int, public_numbers: EllipticCurvePublicNumbers ): if not isinstance(private_value, int): raise TypeError("private_value must be an integer.") if not isinstance(public_numbers, EllipticCurvePublicNumbers): raise TypeError( "public_numbers must be an EllipticCurvePublicNumbers " "instance." ) self._private_value = private_value self._public_numbers = public_numbers def private_key(self, backend=None) -> EllipticCurvePrivateKey: backend = _get_backend(backend) return backend.load_elliptic_curve_private_numbers(self) private_value = utils.read_only_property("_private_value") public_numbers = utils.read_only_property("_public_numbers") def __eq__(self, other): if not isinstance(other, EllipticCurvePrivateNumbers): return NotImplemented return ( self.private_value == other.private_value and self.public_numbers == other.public_numbers ) def __ne__(self, other): return not self == other def __hash__(self): return hash((self.private_value, self.public_numbers)) class ECDH(object): pass _OID_TO_CURVE = { EllipticCurveOID.SECP192R1: SECP192R1, EllipticCurveOID.SECP224R1: SECP224R1, EllipticCurveOID.SECP256K1: SECP256K1, EllipticCurveOID.SECP256R1: SECP256R1, EllipticCurveOID.SECP384R1: SECP384R1, EllipticCurveOID.SECP521R1: SECP521R1, EllipticCurveOID.BRAINPOOLP256R1: BrainpoolP256R1, EllipticCurveOID.BRAINPOOLP384R1: BrainpoolP384R1, EllipticCurveOID.BRAINPOOLP512R1: BrainpoolP512R1, EllipticCurveOID.SECT163K1: SECT163K1, EllipticCurveOID.SECT163R2: SECT163R2, EllipticCurveOID.SECT233K1: SECT233K1, EllipticCurveOID.SECT233R1: SECT233R1, EllipticCurveOID.SECT283K1: SECT283K1, EllipticCurveOID.SECT283R1: SECT283R1, EllipticCurveOID.SECT409K1: SECT409K1, EllipticCurveOID.SECT409R1: SECT409R1, EllipticCurveOID.SECT571K1: SECT571K1, EllipticCurveOID.SECT571R1: SECT571R1, } def get_curve_for_oid(oid: ObjectIdentifier) -> typing.Type[EllipticCurve]: try: return _OID_TO_CURVE[oid] except KeyError: raise LookupError( "The provided object identifier has no matching elliptic " "curve class" ) x25519.py 0000644 00000005034 15030211711 0005764 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc from cryptography.exceptions import UnsupportedAlgorithm, _Reasons from cryptography.hazmat.primitives import _serialization class X25519PublicKey(metaclass=abc.ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> "X25519PublicKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x25519_supported(): raise UnsupportedAlgorithm( "X25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x25519_load_public_bytes(data) @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ The serialized bytes of the public key. """ class X25519PrivateKey(metaclass=abc.ABCMeta): @classmethod def generate(cls) -> "X25519PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x25519_supported(): raise UnsupportedAlgorithm( "X25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x25519_generate_key() @classmethod def from_private_bytes(cls, data: bytes) -> "X25519PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.x25519_supported(): raise UnsupportedAlgorithm( "X25519 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, ) return backend.x25519_load_private_bytes(data) @abc.abstractmethod def public_key(self) -> X25519PublicKey: """ The serialized bytes of the public key. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ) -> bytes: """ The serialized bytes of the private key. """ @abc.abstractmethod def exchange(self, peer_public_key: X25519PublicKey) -> bytes: """ Performs a key exchange operation using the provided peer's public key. """ __init__.py 0000644 00000001615 15030211711 0006647 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc class AsymmetricSignatureContext(metaclass=abc.ABCMeta): @abc.abstractmethod def update(self, data): """ Processes the provided bytes and returns nothing. """ @abc.abstractmethod def finalize(self): """ Returns the signature as bytes. """ class AsymmetricVerificationContext(metaclass=abc.ABCMeta): @abc.abstractmethod def update(self, data): """ Processes the provided bytes and returns nothing. """ @abc.abstractmethod def verify(self): """ Raises an exception if the bytes provided to update do not match the signature or the signature does not match the public key. """ ed448.py 0000644 00000005106 15030211711 0005737 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import abc from cryptography.exceptions import UnsupportedAlgorithm, _Reasons from cryptography.hazmat.primitives import _serialization class Ed448PublicKey(metaclass=abc.ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> "Ed448PublicKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed448_supported(): raise UnsupportedAlgorithm( "ed448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed448_load_public_bytes(data) @abc.abstractmethod def public_bytes( self, encoding: _serialization.Encoding, format: _serialization.PublicFormat, ) -> bytes: """ The serialized bytes of the public key. """ @abc.abstractmethod def verify(self, signature: bytes, data: bytes): """ Verify the signature. """ class Ed448PrivateKey(metaclass=abc.ABCMeta): @classmethod def generate(cls) -> "Ed448PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed448_supported(): raise UnsupportedAlgorithm( "ed448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed448_generate_key() @classmethod def from_private_bytes(cls, data: bytes) -> "Ed448PrivateKey": from cryptography.hazmat.backends.openssl.backend import backend if not backend.ed448_supported(): raise UnsupportedAlgorithm( "ed448 is not supported by this version of OpenSSL.", _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, ) return backend.ed448_load_private_bytes(data) @abc.abstractmethod def public_key(self) -> Ed448PublicKey: """ The Ed448PublicKey derived from the private key. """ @abc.abstractmethod def sign(self, data: bytes) -> bytes: """ Signs the data. """ @abc.abstractmethod def private_bytes( self, encoding: _serialization.Encoding, format: _serialization.PrivateFormat, encryption_algorithm: _serialization.KeySerializationEncryption, ): """ The serialized bytes of the private key. """ utils.py 0000644 00000002311 15030211711 0006242 0 ustar 00 # This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import typing from cryptography import utils from cryptography.hazmat._der import ( DERReader, INTEGER, SEQUENCE, encode_der, encode_der_integer, ) from cryptography.hazmat.primitives import hashes def decode_dss_signature(signature: bytes) -> typing.Tuple[int, int]: with DERReader(signature).read_single_element(SEQUENCE) as seq: r = seq.read_element(INTEGER).as_integer() s = seq.read_element(INTEGER).as_integer() return r, s def encode_dss_signature(r: int, s: int) -> bytes: return encode_der( SEQUENCE, encode_der(INTEGER, encode_der_integer(r)), encode_der(INTEGER, encode_der_integer(s)), ) class Prehashed(object): def __init__(self, algorithm: hashes.HashAlgorithm): if not isinstance(algorithm, hashes.HashAlgorithm): raise TypeError("Expected instance of HashAlgorithm.") self._algorithm = algorithm self._digest_size = algorithm.digest_size digest_size = utils.read_only_property("_digest_size")
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings