Type Alias dryoc::kx::protected::LockedROKeyPair

pub type LockedROKeyPair = KeyPair<LockedRO<PublicKey>, LockedRO<SecretKey>>;

Available on crate feature nightly only.

Heap-allocated, paged-aligned keypair type alias for use with protected memory

Aliased Type

struct LockedROKeyPair {
    pub public_key: Protected<HeapByteArray<32>, ReadOnly, Locked>,
    pub secret_key: Protected<HeapByteArray<32>, ReadOnly, Locked>,
}

Fields

public_key: Protected<HeapByteArray<32>, ReadOnly, Locked>

Public key

secret_key: Protected<HeapByteArray<32>, ReadOnly, Locked>

Secret key

Implementations

impl KeyPair<LockedRO<HeapByteArray<CRYPTO_BOX_PUBLICKEYBYTES>>, LockedRO<HeapByteArray<CRYPTO_BOX_SECRETKEYBYTES>>>

pub fn gen_readonly_locked_keypair() -> Result<Self, Error>

Returns a new randomly generated locked, read-only keypair.

impl<'a, PublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + TryFrom<&'a [u8]> + Zeroize, SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + TryFrom<&'a [u8]> + Zeroize> KeyPair<PublicKey, SecretKey>

pub fn from_slices( public_key: &'a [u8], secret_key: &'a [u8], ) -> Result<Self, Error>

Constructs a new keypair from key slices, consuming them. Does not check validity or authenticity of keypair.

impl<PublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> KeyPair<PublicKey, SecretKey>

pub fn kx_new_client_session<SessionKey: NewByteArray<CRYPTO_KX_SESSIONKEYBYTES> + Zeroize>( &self, server_public_key: &PublicKey, ) -> Result<Session<SessionKey>, Error>

Creates new client session keys using this keypair and server_public_key, assuming this keypair is for the client.

pub fn kx_new_server_session<SessionKey: NewByteArray<CRYPTO_KX_SESSIONKEYBYTES> + Zeroize>( &self, client_public_key: &PublicKey, ) -> Result<Session<SessionKey>, Error>

Creates new server session keys using this keypair and client_public_key, assuming this keypair is for the server.

impl<PublicKey: NewByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: NewByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> KeyPair<PublicKey, SecretKey>

pub fn new() -> Self

Creates a new, empty keypair.

pub fn gen() -> Self

Generates a random keypair.

pub fn from_secret_key(secret_key: SecretKey) -> Self

Derives a keypair from secret_key, and consumes it, and returns a new keypair.

pub fn from_seed<Seed: Bytes>(seed: &Seed) -> Self

Derives a keypair from seed, returning a new keypair.

Trait Implementations

impl<PublicKey: Clone + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: Clone + ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> Clone for KeyPair<PublicKey, SecretKey>

fn clone(&self) -> KeyPair<PublicKey, SecretKey>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<PublicKey: Debug + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: Debug + ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> Debug for KeyPair<PublicKey, SecretKey>

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

Formats the value using the given formatter.

impl<PublicKey: NewByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: NewByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> Default for KeyPair<PublicKey, SecretKey>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, PublicKey, SecretKey> Deserialize<'de> for KeyPair<PublicKey, SecretKey>

where PublicKey: Deserialize<'de> + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: Deserialize<'de> + ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<PublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> Drop for KeyPair<PublicKey, SecretKey>

fn drop(&mut self)

Executes the destructor for this type.

impl<PublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize> PartialEq for KeyPair<PublicKey, SecretKey>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<PublicKey, SecretKey> Serialize for KeyPair<PublicKey, SecretKey>

where PublicKey: Serialize + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, SecretKey: Serialize + ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<PublicKey, SecretKey> Zeroize for KeyPair<PublicKey, SecretKey>

where PublicKey: Zeroize + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, SecretKey: Zeroize + ByteArray<CRYPTO_BOX_SECRETKEYBYTES>,

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.