Struct cryptimitives::key::KeyPair

pub struct KeyPair<SK> where
    SK: SecretKey,  { /* private fields */ }

Trait Implementations

impl<SK: Clone> Clone for KeyPair<SK> where
    SK: SecretKey,
    SK::PK: Clone, 

fn clone(&self) -> KeyPair<SK>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<SK> Debug for KeyPair<SK> where
    SK: SecretKey, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<SK> Default for KeyPair<SK> where
    SK: SecretKey, 

fn default() -> Self

Returns the “default value” for a type.

impl<SK> DiffieHellman for KeyPair<SK> where
    SK: SecretKey + Sign + DiffieHellman, 

type SSK = <SK as DiffieHellman>::SSK

type PK = <SK as DiffieHellman>::PK

fn diffie_hellman(&self, peer_public: &Self::PK) -> <SK as DiffieHellman>::SSK

Derives SharedSecretKey from the other PublicKey

impl<SK> Drop for KeyPair<SK> where
    SK: SecretKey, 

fn drop(&mut self)

Executes the destructor for this type.

impl<SK> FromBytes for KeyPair<SK> where
    SK: SecretKey + FromBytes + Len,
    SK::PK: FromBytes + Len,
    KeyPairError: From<<SK as FromBytes>::E> + From<<<SK as SecretKey>::PK as FromBytes>::E>, 

type E = KeyPairError

fn from_bytes(bytes: &[u8]) -> Result<Self, Self::E>

Construct a value from a slice of bytes.

impl<SK> KeyPair for KeyPair<SK> where
    SK: SecretKey, 

type SK = SK

fn generate_with<R>(csprng: R) -> Self where
    R: CryptoRng + RngCore, 

Generates an “unbiased” KeyPair directly from a user suplied csprng uniformly.

fn public(&self) -> &<Self::SK as SecretKey>::PK

Get a PublicKey of KeyPair.

fn to_public(&self) -> SK::PK

Derives the PublicKey corresponding to KeyPair SK;

fn secret(&self) -> &Self::SK

Get a SecretKey of KeyPair.

fn generate() -> Self

Generate an “unbiased” KeyPair.

impl<SK> Len for KeyPair<SK> where
    SK: SecretKey + Len,
    SK::PK: Len, 

const LEN: usize

impl<SK> Sign for KeyPair<SK> where
    SK: SecretKey + Sign, 

type SIG = <SK as Sign>::SIG

fn sign(&self, data: &[u8]) -> Self::SIG where
    Self: Sized, 

Sign a message.

impl<SK> ToVec for KeyPair<SK> where
    SK: SecretKey + ToVec + Len,
    SK::PK: ToVec + Len, 

fn to_vec(&self) -> Vec<u8>

Convert a key into a vec of bytes.

impl<SK> Verify for KeyPair<SK> where
    SK: SecretKey,
    SK::PK: Verify<E = SignatureError>, 

type E = SignatureError

type SIG = <SK::PK as Verify>::SIG

fn verify(&self, data: &[u8], signature: &Self::SIG) -> Result<(), Self::E>

Verify a signature

impl<SK> Zeroize for KeyPair<SK> where
    SK: SecretKey, 

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.