FM / asymmetric

/opt/imunify360/venv/lib/python3.11/site-packages/cryptography/hazmat/primitives/asymmetric/

/opt/imunify360/venv/lib/python3.11/site-packages/cryptography/hazmat/primitives/asymmetric

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
dh.py	3420	0644	edit dl rm
dsa.py	3945	0644	edit dl rm
ec.py	10428	0644	edit dl rm
ed448.py	3456	0644	edit dl rm
ed25519.py	3423	0644	edit dl rm
padding.py	2885	0644	edit dl rm
rsa.py	7637	0644	edit dl rm
types.py	2996	0644	edit dl rm
utils.py	790	0644	edit dl rm
x448.py	3374	0644	edit dl rm
x25519.py	3341	0644	edit dl rm
__init__.py	180	0644	edit dl rm

Edit: /opt/imunify360/venv/lib/python3.11/site-packages/cryptography/hazmat/primitives/asymmetric/x448.py (3374B)

# 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.

from __future__ import annotations

import abc

from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
from cryptography.hazmat.bindings._rust import openssl as rust_openssl
from cryptography.hazmat.primitives import _serialization

class X448PublicKey(metaclass=abc.ABCMeta):
    @classmethod
    def from_public_bytes(cls, data: bytes) -> 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 rust_openssl.x448.from_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 public_bytes_raw(self) -> bytes:
        """
        The raw bytes of the public key.
        Equivalent to public_bytes(Raw, Raw).
        """

@abc.abstractmethod
    def __eq__(self, other: object) -> bool:
        """
        Checks equality.
        """

if hasattr(rust_openssl, "x448"):
    X448PublicKey.register(rust_openssl.x448.X448PublicKey)

class X448PrivateKey(metaclass=abc.ABCMeta):
    @classmethod
    def generate(cls) -> X448PrivateKey:
        from cryptography.hazmat.backends.openssl.backend import backend

return rust_openssl.x448.generate_key()

@classmethod
    def from_private_bytes(cls, data: bytes) -> X448PrivateKey:
        from cryptography.hazmat.backends.openssl.backend import backend

return rust_openssl.x448.from_private_bytes(data)

@abc.abstractmethod
    def public_key(self) -> X448PublicKey:
        """
        Returns the public key associated with this private 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 private_bytes_raw(self) -> bytes:
        """
        The raw bytes of the private key.
        Equivalent to private_bytes(Raw, Raw, NoEncryption()).
        """

@abc.abstractmethod
    def exchange(self, peer_public_key: X448PublicKey) -> bytes:
        """
        Performs a key exchange operation using the provided peer's public key.
        """

if hasattr(rust_openssl, "x448"):
    X448PrivateKey.register(rust_openssl.x448.X448PrivateKey)

cmd: