[][src]Crate ed25519

Ed25519 signatures.

Edwards Digital Signature Algorithm (EdDSA) over Curve25519 as specified in RFC 8032: https://tools.ietf.org/html/rfc8032

This crate doesn't contain an implementation of Ed25519, but instead contains an ed25519::Signature type which other crates can use in conjunction with the signature::Signer and signature::Verifier traits defined in the signature crate.

These traits allow crates which produce and consume Ed25519 signatures to be written abstractly in such a way that different signing_key/verifier providers can be plugged in, enabling support for using different Ed25519 implementations, including HSMs or Cloud KMS services.

Minimum Supported Rust Version

Rust 1.41 or higher.

Minimum supported Rust version may be changed in the future, but such changes will be accompanied with a minor version bump.

Using Ed25519 generically over algorithm implementations/providers

By using the ed25519 crate, you can write code which signs and verifies messages using the Ed25519 signature algorithm generically over any supported Ed25519 implementation (see the next section for available providers).

This allows consumers of your code to plug in whatever implementation they want to use without having to add all potential Ed25519 libraries you'd like to support as optional dependencies.


use ed25519::signature::{Signer, Verifier};

pub struct HelloSigner<S>
    S: Signer<ed25519::Signature>
    pub signing_key: S

impl<S> HelloSigner<S>
    S: Signer<ed25519::Signature>
    pub fn sign(&self, person: &str) -> ed25519::Signature {
        // NOTE: use `try_sign` if you'd like to be able to handle
        // errors from external signing services/devices (e.g. HSM/KMS)
        // <https://docs.rs/signature/latest/signature/trait.Signer.html#tymethod.try_sign>

pub struct HelloVerifier<V> {
    pub verifier: V

impl<V> HelloVerifier<V>
    V: Verifier<ed25519::Signature>
    pub fn verify(
        person: &str,
        signature: &ed25519::Signature
    ) -> Result<(), ed25519::Error> {
        self.verifier.verify(format_message(person).as_bytes(), signature)

fn format_message(person: &str) -> String {
    format!("Hello, {}!", person)

Using above example with ed25519-dalek

The ed25519-dalek crate natively supports the ed25519::Signature type defined in this crate along with the the signature::Signer and signature::Verifier traits.

Below is an example of how a hypothetical consumer of the code above can instantiate and use the previously defined HelloSigner and HelloVerifier types with ed25519-dalek as the signing/verification provider:

use ed25519_dalek::{Signer, Verifier, Signature};
use rand_core::OsRng; // Requires the `std` feature of `rand_core`

/// `HelloSigner` defined above instantiated with `ed25519-dalek` as
/// the signing provider.
pub type DalekHelloSigner = HelloSigner<ed25519_dalek::Keypair>;

let signing_key = ed25519_dalek::Keypair::generate(&mut OsRng);
let signer = DalekHelloSigner { signing_key };
let person = "Joe"; // Message to sign
let signature = signer.sign(person);

/// `HelloVerifier` defined above instantiated with `ed25519-dalek`
/// as the signature verification provider.
pub type DalekHelloVerifier = HelloVerifier<ed25519_dalek::PublicKey>;

let verify_key: ed25519_dalek::PublicKey = signer.signing_key.public;
let verifier = DalekHelloVerifier { verify_key };
assert!(verifier.verify(person, &signature).is_ok());

Available Ed25519 providers

The following libraries natively support the types and traits from the ed25519 crate:

  • ed25519-dalek - mature pure Rust implementation of Ed25519
  • yubihsm - host-side client library for YubiHSM2 devices from Yubico

The Signatory project provides wrappers for several notable crates which produce/verify Ed25519 signatures:


pub use signature;



Signature errors.


Ed25519 signature.



Length of an Ed25519 signature