Struct xxxdh::KeyPair

pub struct KeyPair<S, P> where
    S: SecretKey,
    P: PublicKey,  { /* fields omitted */ }

Trait Implementations

impl<S, P> Debug for KeyPair<S, P> where
    S: SecretKey,
    P: PublicKey, 

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

Formats the value using the given formatter.

impl<S, P> Default for KeyPair<S, P> where
    S: SecretKey<P = P>,
    P: PublicKey, 

fn default() -> Self

Returns the “default value” for a type.

impl<S, P> DiffieHellman for KeyPair<S, P> where
    S: SecretKey<P = P> + Sign + DiffieHellman,
    P: PublicKey, 

type S = <S as DiffieHellman>::S

type P = <S as DiffieHellman>::P

fn diffie_hellman(&self, peer_public: &Self::P) -> <S as DiffieHellman>::S

impl<S, P> Drop for KeyPair<S, P> where
    S: SecretKey,
    P: PublicKey, 

fn drop(&mut self)

Executes the destructor for this type.

impl<S, P> FromBytes for KeyPair<S, P> where
    S: SecretKey<P = P> + FromBytes,
    P: PublicKey + FromBytes, 

fn from_bytes(bytes: &[u8]) -> Result<KeyPair<S, P>, KeypairError>

Deserialize a IdentityKeyPair from bytes.

Inputs

• bytes: an &[u8] consisting of byte representations of first a SecretKey and then the corresponding PublicKey.

Returns

A Result whose okay value is a Keypair or whose error value is an KeypairError describing the error that occurred.

const LEN: usize

impl<S, P> SecretKey for KeyPair<S, P> where
    S: SecretKey<P = P>,
    P: PublicKey, 

X3DH Keypair.

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

Generate a KeyPair;

fn to_public(&self) -> S::P

Get a PublicKey of KeyPair.

type P = P

impl<S, P> Sign for KeyPair<S, P> where
    S: SecretKey<P = P> + Sign,
    P: PublicKey, 

type S = <S as Sign>::S

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

Sign a message.

impl<S, P> ToVec for KeyPair<S, P> where
    S: SecretKey<P = P> + ToVec,
    P: PublicKey + ToVec, 

const LEN: usize

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

Convert a key into a vec of bytes.

impl<'a, S, P> Verify for KeyPair<S, P> where
    S: SecretKey<P = P>,
    P: PublicKey + Verify, 

type S = <P as Verify>::S

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

Verify a signature

impl<S, P> Zeroize for KeyPair<S, P> where
    S: SecretKey,
    P: PublicKey, 

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.