Struct schnorrkel::keys::MiniSecretKey

pub struct MiniSecretKey(_);

An EdDSA-like “secret” key seed.

These are seeds from which we produce a real SecretKey, which EdDSA itself calls an extended secret key by hashing. We require homomorphic properties unavailable from these seeds, so we renamed these and reserve SecretKey for what EdDSA calls an extended secret key.

Implementations

impl MiniSecretKey

pub const UNIFORM_MODE: ExpansionMode

Avoids importing ExpansionMode

pub const ED25519_MODE: ExpansionMode

Avoids importing ExpansionMode

pub fn expand(&self, mode: ExpansionMode) -> SecretKey

Derive the SecretKey corresponding to this MiniSecretKey.

We caution that mode must always be chosen consistently. We slightly prefer ExpansionMode::Uniform here, but both remain secure under almost all situations. There exists deployed code using ExpansionMode::Ed25519, so you might require that for compatability.

use rand::{Rng, rngs::OsRng};
use schnorrkel::{MiniSecretKey, SecretKey, ExpansionMode};

let mini_secret_key: MiniSecretKey = MiniSecretKey::generate_with(OsRng);
let secret_key: SecretKey = mini_secret_key.expand(ExpansionMode::Uniform);

pub fn expand_to_keypair(&self, mode: ExpansionMode) -> Keypair

Derive the Keypair corresponding to this MiniSecretKey.

pub fn expand_to_public(&self, mode: ExpansionMode) -> PublicKey

Derive the PublicKey corresponding to this MiniSecretKey.

pub fn to_bytes(&self) -> [u8; 32]

Convert this secret key to a byte array.

pub fn as_bytes(&self) -> &[u8; 32]

View this secret key as a byte array.

pub fn from_bytes(bytes: &[u8]) -> SignatureResult<MiniSecretKey>

Construct a MiniSecretKey from a slice of bytes.

Example

use schnorrkel::{MiniSecretKey, MINI_SECRET_KEY_LENGTH};

let secret_key_bytes: [u8; MINI_SECRET_KEY_LENGTH] = [
   157, 097, 177, 157, 239, 253, 090, 096,
   186, 132, 074, 244, 146, 236, 044, 196,
   068, 073, 197, 105, 123, 050, 105, 025,
   112, 059, 172, 003, 028, 174, 127, 096, ];

let secret_key: MiniSecretKey = MiniSecretKey::from_bytes(&secret_key_bytes).unwrap();

Returns

A Result whose okay value is an EdDSA MiniSecretKey or whose error value is an SignatureError wrapping the internal error that occurred.

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

Generate a MiniSecretKey from a csprng.

Example

use rand::{Rng, rngs::OsRng};
use schnorrkel::{PublicKey, MiniSecretKey, Signature};

let secret_key: MiniSecretKey = MiniSecretKey::generate_with(OsRng);

Input

A CSPRNG with a fill_bytes() method, e.g. rand_chacha::ChaChaRng

pub fn generate() -> MiniSecretKey

Generate a MiniSecretKey from rand’s thread_rng.

Example

use schnorrkel::{PublicKey, MiniSecretKey, Signature};

let secret_key: MiniSecretKey = MiniSecretKey::generate();

Afterwards, you can generate the corresponding public key.

let public_key: PublicKey = secret_key.expand_to_public(ExpansionMode::Ed25519);

impl MiniSecretKey

pub fn hard_derive_mini_secret_key<B: AsRef<[u8]>>(
    &self,
    cc: Option<ChainCode>,
    i: B,
    mode: ExpansionMode
) -> (MiniSecretKey, ChainCode)

Vaguely BIP32-like “hard” derivation of a MiniSecretKey from a SecretKey

We do not envision any “good reasons” why these “hard” derivations should ever be used after the soft Derivation trait. We similarly do not believe hard derivations make any sense for ChainCodes or ExtendedKeys types. Yet, some existing BIP32 workflows might do these things, due to BIP32’s de facto stnadardization and poor design. In consequence, we provide this method to do “hard” derivations in a way that should work with all BIP32 workflows and any permissible mutations of SecretKey. This means only that we hash the SecretKey’s scalar, but not its nonce becuase the secret key remains valid if the nonce is changed.

Trait Implementations

impl Clone for MiniSecretKey

fn clone(&self) -> MiniSecretKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConstantTimeEq for MiniSecretKey

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

impl Debug for MiniSecretKey

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

Formats the value using the given formatter.

impl<'d> Deserialize<'d> for MiniSecretKey

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'d>, 

Deserialize this value from the given Serde deserializer.

impl Drop for MiniSecretKey

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<MiniSecretKey> for MiniSecretKey

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

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

#[must_use]

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

This method tests for !=.

impl Serialize for MiniSecretKey

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl Zeroize for MiniSecretKey

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 Eq for MiniSecretKey