Struct LocalKey 

pub struct LocalKey { /* private fields */ }

A stored key entry

Implementations

impl LocalKey

pub fn generate_with_rng(alg: KeyAlg, ephemeral: bool) -> Result<Self, Error>

Create a new random key or keypair

pub fn generate_for_hardware( alg: KeyAlg, ephemeral: bool, ) -> Result<Self, Error>

Create a new random keypair backed by hardware

pub fn from_id(alg: KeyAlg, id: &str) -> Result<Self, Error>

Get a local key by id

pub fn from_seed( alg: KeyAlg, seed: &[u8], method: Option<&str>, ) -> Result<Self, Error>

Create a new deterministic key or keypair

pub fn from_jwk_slice(jwk: &[u8]) -> Result<Self, Error>

Import a key or keypair from a JWK in binary format

pub fn from_jwk(jwk: &str) -> Result<Self, Error>

Import a key or keypair from a JWK

pub fn from_public_bytes(alg: KeyAlg, public: &[u8]) -> Result<Self, Error>

Import a public key from its compact representation

pub fn to_public_bytes(&self) -> Result<SecretBytes, Error>

Export the raw bytes of the public key

pub fn from_secret_bytes(alg: KeyAlg, secret: &[u8]) -> Result<Self, Error>

Import a symmetric key or public-private keypair from its compact representation

pub fn to_secret_bytes(&self) -> Result<SecretBytes, Error>

Export the raw bytes of the private key

pub fn to_key_exchange(&self, alg: KeyAlg, pk: &LocalKey) -> Result<Self, Error>

Derive a new key from a Diffie-Hellman exchange between this keypair and a public key

pub fn algorithm(&self) -> KeyAlg

Accessor for the key algorithm

pub fn to_jwk_public(&self, alg: Option<KeyAlg>) -> Result<String, Error>

Get the public JWK representation for this key or keypair

pub fn to_jwk_secret(&self) -> Result<SecretBytes, Error>

Get the JWK representation for this private key or keypair

pub fn to_jwk_thumbprint(&self, alg: Option<KeyAlg>) -> Result<String, Error>

Get the JWK thumbprint for this key or keypair

pub fn to_jwk_thumbprints(&self) -> Result<Vec<String>, Error>

Get the set of indexed JWK thumbprints for this key or keypair

pub fn convert_key(&self, alg: KeyAlg) -> Result<Self, Error>

Map this key or keypair to its equivalent for another key algorithm

pub fn aead_params(&self) -> Result<KeyAeadParams, Error>

Fetch the AEAD parameter lengths

pub fn aead_padding(&self, msg_len: usize) -> usize

Calculate the padding required for a message

pub fn aead_random_nonce(&self) -> Result<Vec<u8>, Error>

Create a new random nonce for AEAD message encryption

pub fn aead_encrypt( &self, message: &[u8], nonce: &[u8], aad: &[u8], ) -> Result<Encrypted, Error>

Perform AEAD message encryption with this encryption key

pub fn aead_decrypt<'d>( &'d self, ciphertext: impl Into<ToDecrypt<'d>>, nonce: &[u8], aad: &[u8], ) -> Result<SecretBytes, Error>

Perform AEAD message decryption with this encryption key

pub fn sign_message( &self, message: &[u8], sig_type: Option<&str>, ) -> Result<Vec<u8>, Error>

Sign a message with this private signing key

pub fn verify_signature( &self, message: &[u8], signature: &[u8], sig_type: Option<&str>, ) -> Result<bool, Error>

Verify a message signature with this private signing key or public verification key

pub fn wrap_key(&self, key: &LocalKey, nonce: &[u8]) -> Result<Encrypted, Error>

Wrap another key using this key

pub fn unwrap_key<'d>( &'d self, alg: KeyAlg, ciphertext: impl Into<ToDecrypt<'d>>, nonce: &[u8], ) -> Result<LocalKey, Error>

Unwrap a key using this key

pub fn is_hardware_backed(&self) -> bool

Check whether the key is hardware backed by checking the type id of the underlying structure

Trait Implementations

impl Debug for LocalKey

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

Formats the value using the given formatter.

impl KeyExchange for LocalKey

fn write_key_exchange( &self, other: &LocalKey, out: &mut dyn WriteBuffer, ) -> Result<(), CryptoError>

Perform a key exchange, writing the result to the provided buffer.

fn key_exchange_bytes(&self, other: &Rhs) -> Result<SecretBytes, Error>

Perform a key exchange and return a new allocated buffer.