Struct ed25519_dalek::ExpandedSecretKey

pub struct ExpandedSecretKey { /* private fields */ }

An “expanded” secret key.

This is produced by using an hash function with 512-bits output to digest a SecretKey. The output digest is then split in half, the lower half being the actual key used to sign messages, after twiddling with some bits.¹ The upper half is used a sort of half-baked, ill-designed² pseudo-domain-separation “nonce”-like thing, which is used during signature production by concatenating it with the message to be signed before the message is hashed.

Instances of this secret are automatically overwritten with zeroes when they fall out of scope.

Implementations

impl ExpandedSecretKey

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

Convert this ExpandedSecretKey into an array of 64 bytes.

Returns

An array of 64 bytes. The first 32 bytes represent the “expanded” secret key, and the last 32 bytes represent the “domain-separation” “nonce”.

Examples

use rand::rngs::OsRng;
use ed25519_dalek::{SecretKey, ExpandedSecretKey};

let mut csprng = OsRng{};
let secret_key: SecretKey = SecretKey::generate(&mut csprng);
let expanded_secret_key: ExpandedSecretKey = ExpandedSecretKey::from(&secret_key);
let expanded_secret_key_bytes: [u8; 64] = expanded_secret_key.to_bytes();

assert!(&expanded_secret_key_bytes[..] != &[0u8; 64][..]);

pub fn from_bytes(bytes: &[u8]) -> Result<ExpandedSecretKey, SignatureError>

Construct an ExpandedSecretKey from a slice of bytes.

Returns

A Result whose okay value is an EdDSA ExpandedSecretKey or whose error value is an SignatureError describing the error that occurred.

Examples

use rand::rngs::OsRng;
use ed25519_dalek::{SecretKey, ExpandedSecretKey};
use ed25519_dalek::SignatureError;

let mut csprng = OsRng{};
let secret_key: SecretKey = SecretKey::generate(&mut csprng);
let expanded_secret_key: ExpandedSecretKey = ExpandedSecretKey::from(&secret_key);
let bytes: [u8; 64] = expanded_secret_key.to_bytes();
let expanded_secret_key_again = ExpandedSecretKey::from_bytes(&bytes)?;

pub fn sign(&self, message: &[u8], public_key: &PublicKey) -> Signature

Sign a message with this ExpandedSecretKey.

pub fn sign_prehashed<'a, D>(
    &self,
    prehashed_message: D,
    public_key: &PublicKey,
    context: Option<&'a [u8]>
) -> Result<Signature, SignatureError> where
    D: Digest<OutputSize = U64>, 

Sign a prehashed_message with this ExpandedSecretKey using the Ed25519ph algorithm defined in RFC8032 §5.1.

Inputs

• prehashed_message is an instantiated hash digest with 512-bits of output which has had the message to be signed previously fed into its state.
• public_key is a PublicKey which corresponds to this secret key.
• context is an optional context string, up to 255 bytes inclusive, which may be used to provide additional domain separation. If not set, this will default to an empty string.

Returns

A Result whose Ok value is an Ed25519ph [Signature] on the prehashed_message if the context was 255 bytes or less, otherwise a SignatureError.

Trait Implementations

impl<'d> Deserialize<'d> for ExpandedSecretKey

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

Deserialize this value from the given Serde deserializer.

impl Drop for ExpandedSecretKey

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> From<&'a ExpandedSecretKey> for PublicKey

fn from(expanded_secret_key: &ExpandedSecretKey) -> PublicKey

Derive this public key from its corresponding ExpandedSecretKey.

impl<'a> From<&'a SecretKey> for ExpandedSecretKey

fn from(secret_key: &'a SecretKey) -> ExpandedSecretKey

Construct an ExpandedSecretKey from a SecretKey.

Examples

use rand::rngs::OsRng;
use ed25519_dalek::{SecretKey, ExpandedSecretKey};

let mut csprng = OsRng{};
let secret_key: SecretKey = SecretKey::generate(&mut csprng);
let expanded_secret_key: ExpandedSecretKey = ExpandedSecretKey::from(&secret_key);

impl Serialize for ExpandedSecretKey

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 ExpandedSecretKey

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.