Struct PyPublicKey 

pub struct PyPublicKey { /* private fields */ }

An asymmetric public key.

Supports RSA, EC (P-256, P-384, P-521), Ed25519, Ed448, and DSA keys. Load from PEM or SubjectPublicKeyInfo DER; serialize back to PEM or DER. RSA keys can encrypt data with OAEP or PKCS#1 v1.5 padding.

import synta

# Load an RSA public key from a PEM file:
with open("rsa_pub.pem", "rb") as f:
    pub = synta.PublicKey.from_pem(f.read())
print(pub.key_type)   # "rsa"
print(pub.key_size)   # e.g. 2048

# Encrypt with OAEP (SHA-256):
ct = pub.rsa_oaep_encrypt(b"secret", "sha256")

# Load an EC public key from SPKI DER:
ec_pub = synta.PublicKey.from_der(spki_der)
print(ec_pub.curve_name)  # "P-256"

Trait Implementations

impl DerefToPyAny for PyPublicKey

impl ExtractPyClassWithClone for PyPublicKey

impl<'py> IntoPyObject<'py> for PyPublicKey

type Target = PyPublicKey

The Python output type

type Output = Bound<'py, <PyPublicKey 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 PyClass for PyPublicKey

type Frozen = True

Whether the pyclass is frozen.

impl PyClassImpl for PyPublicKey

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 public key. /// /// Supports RSA, EC (P-256, P-384, P-521), Ed25519, Ed448, and DSA keys. /// Load from PEM or SubjectPublicKeyInfo DER; serialize back to PEM or DER. /// RSA keys can encrypt data with OAEP or PKCS\#1 v1.5 padding. /// /// ```python,ignore /// import synta /// /// # Load an RSA public key from a PEM file: /// with open("rsa_pub.pem", "rb") as f: /// pub = synta.PublicKey.from_pem(f.read()) /// print(pub.key_type) # "rsa" /// print(pub.key_size) # e.g. 2048 /// /// # Encrypt with OAEP (SHA-256): /// ct = pub.rsa_oaep_encrypt(b"secret", "sha256") /// /// # Load an EC public key from SPKI DER: /// ec_pub = synta.PublicKey.from_der(spki_der) /// print(ec_pub.curve_name) # "P-256" /// ```

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<PyPublicKey>

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<PyPublicKey> for PyClassImplCollector<PyPublicKey>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyPublicKey

const NAME: &'static str = "PublicKey"

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.