Struct ed25519_dalek::Context

pub struct Context<'k, 'v, K> { /* private fields */ }

Available on crate feature digest only.

Ed25519 contexts as used by Ed25519ph.

Contexts are domain separator strings that can be used to isolate uses of the algorithm between different protocols (which is very hard to reliably do otherwise) and between different uses within the same protocol.

To create a context, call either of the following:

• SigningKey::with_context
• VerifyingKey::with_context

For more information, see RFC8032 § 8.3.

Example

use ed25519_dalek::{Signature, SigningKey, VerifyingKey, Sha512};
use ed25519_dalek::{DigestSigner, DigestVerifier};

let context_str = b"Local Channel 3";
let prehashed_message = Sha512::default().chain_update(b"Stay tuned for more news at 7");

// Signer
let signing_context = signing_key.with_context(context_str).unwrap();
let signature = signing_context.sign_digest(prehashed_message.clone());

// Verifier
let verifying_context = verifying_key.with_context(context_str).unwrap();
let verified: bool = verifying_context
    .verify_digest(prehashed_message, &signature)
    .is_ok();

Implementations

impl<'k, 'v, K> Context<'k, 'v, K>

pub const MAX_LENGTH: usize = 255usize

Maximum length of the context value in octets.

pub fn key(&self) -> &'k K

Borrow the key.

pub fn value(&self) -> &'v [u8]

Borrow the context string value.

Trait Implementations

impl<'k, 'v, K: Clone> Clone for Context<'k, 'v, K>

fn clone(&self) -> Context<'k, 'v, K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'k, 'v, K: Debug> Debug for Context<'k, 'v, K>

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

Formats the value using the given formatter.

impl<D> DigestSigner<D, Signature> for Context<'_, '_, SigningKey>

where D: Digest<OutputSize = U64>,

Equivalent to SigningKey::sign_prehashed with context set to Some containing self.value().

Note

The RFC only permits SHA-512 to be used for prehashing. This function technically works, and is probably safe to use, with any secure hash function with 512-bit digests, but anything outside of SHA-512 is NOT specification-compliant. We expose crate::Sha512 for user convenience.

fn try_sign_digest(&self, msg_digest: D) -> Result<Signature, SignatureError>

Attempt to sign the given prehashed message Digest, returning a digital signature on success, or an error if something went wrong.

fn sign_digest(&self, digest: D) -> S

Sign the given prehashed message Digest, returning a signature.

impl<MsgDigest> DigestVerifier<MsgDigest, Signature> for Context<'_, '_, VerifyingKey>

where MsgDigest: Digest<OutputSize = U64>,

Equivalent to VerifyingKey::verify_prehashed with context set to Some containing self.value().

fn verify_digest( &self, msg_digest: MsgDigest, signature: &Signature ) -> Result<(), SignatureError>

Verify the signature against the given Digest output.