Struct PyPrivateKey 

pub struct PyPrivateKey { /* private fields */ }

An asymmetric private key.

Supports RSA, EC (P-256, P-384, P-521), Ed25519, Ed448, and DSA keys. Load from PEM (optionally password-protected) or unencrypted PKCS#8 DER; serialize back to PEM (optionally encrypted with AES-256-CBC) or unencrypted PKCS#8 DER. RSA keys can decrypt ciphertext with OAEP or PKCS#1 v1.5 padding.

import synta

# Load an encrypted RSA private key from PEM:
with open("rsa_key.pem", "rb") as f:
    priv = synta.PrivateKey.from_pem(f.read(), password=b"secret")

# Extract the public key:
pub = priv.public_key

# Decrypt RSA-OAEP ciphertext:
plaintext = priv.rsa_oaep_decrypt(ciphertext, "sha256")

Trait Implementations

impl DerefToPyAny for PyPrivateKey

impl ExtractPyClassWithClone for PyPrivateKey

impl<'py> IntoPyObject<'py> for PyPrivateKey

type Target = PyPrivateKey

The Python output type

type Output = Bound<'py, <PyPrivateKey as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PrivateKey for PyPrivateKey

Implement the backend-agnostic synta_certificate::PrivateKey trait for PyPrivateKey by delegating to synta_certificate::BackendPrivateKey.

This allows Python binding code (e.g. cert_builder.rs) to call key.as_signer(algorithm) without importing backend-specific types.

fn public_key_spki_der(&self) -> Result<Vec<u8>, PrivateKeyError>

Return the DER-encoded SubjectPublicKeyInfo for the public half of this key.

fn as_signer(&self, algorithm: &str) -> Box<dyn ErasedCertificateSigner>

Create a CertificateSigner for this key with the given hash algorithm.

impl PyClass for PyPrivateKey

type Frozen = True

Whether the pyclass is frozen.

impl PyClassImpl for PyPrivateKey

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// An asymmetric private key. /// /// Supports RSA, EC (P-256, P-384, P-521), Ed25519, Ed448, and DSA keys. /// Load from PEM (optionally password-protected) or unencrypted PKCS\#8 DER; /// serialize back to PEM (optionally encrypted with AES-256-CBC) or /// unencrypted PKCS\#8 DER. RSA keys can decrypt ciphertext with OAEP or /// PKCS\#1 v1.5 padding. /// /// ```python,ignore /// import synta /// /// # Load an encrypted RSA private key from PEM: /// with open("rsa_key.pem", "rb") as f: /// priv = synta.PrivateKey.from_pem(f.read(), password=b"secret") /// /// # Extract the public key: /// pub = priv.public_key /// /// # Decrypt RSA-OAEP ciphertext: /// plaintext = priv.rsa_oaep_decrypt(ciphertext, "sha256") /// ```

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyPrivateKey>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<PyPrivateKey> for PyClassImplCollector<PyPrivateKey>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyPrivateKey

const NAME: &'static str = "PrivateKey"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.