Struct cryptimitives::key::KeyPair

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

Trait Implementations

impl<SK> Clone for KeyPair<SK>where
    SK: SecretKey + Clone,
    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 + Generate,

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> From<SK> for KeyPair<SK>where
    SK: SecretKey,

fn from(secret: SK) -> Self

Converts to this type from the input 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> Generate for KeyPair<SK>where
    SK: SecretKey + Generate,

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

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

fn generate() -> Self

Generate an “unbiased” SecretKey;

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

type SK = SK

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.

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

const LEN: usize = _

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

fn eq(&self, other: &KeyPair<SK>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

type SIG = <SK as Sign>::SIG

fn sign(&self, data: &[u8]) -> Self::SIGwhere
    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 as SecretKey>::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.

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