[][src]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[src]

pub const UNIFORM_MODE: ExpansionMode[src]

Avoids importing ExpansionMode

pub const ED25519_MODE: ExpansionMode[src]

Avoids importing ExpansionMode

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

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[src]

Derive the Keypair corresponding to this MiniSecretKey.

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

Derive the PublicKey corresponding to this MiniSecretKey.

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

Convert this secret key to a byte array.

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

View this secret key as a byte array.

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

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
[src]

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[src]

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[src]

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

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[src]

impl ConstantTimeEq for MiniSecretKey[src]

impl Debug for MiniSecretKey[src]

impl Drop for MiniSecretKey[src]

impl Eq for MiniSecretKey[src]

impl PartialEq<MiniSecretKey> for MiniSecretKey[src]

impl Zeroize for MiniSecretKey[src]

Auto Trait Implementations

impl RefUnwindSafe for MiniSecretKey

impl Send for MiniSecretKey

impl Sync for MiniSecretKey

impl Unpin for MiniSecretKey

impl UnwindSafe for MiniSecretKey

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 
[src]

impl<Z> Zeroize for Z where
    Z: DefaultIsZeroes
[src]