Enum VerifyingKey

Source

pub enum VerifyingKey {
    Ed25519(Box<VerifyingKey>),
    MlDsa44((Box<MLDSA44VerificationKey>, Hash)),
    MlDsa65((Box<MLDSA65VerificationKey>, Hash)),
    MlDsa87((Box<MLDSA87VerificationKey>, Hash)),
}

Expand description

Public key for signature verification supporting multiple algorithms.

This enum provides a unified interface for verifying signatures across different cryptographic algorithms, supporting both classical and post-quantum schemes.

§Algorithm Selection

Ed25519: Use for legacy compatibility and smaller key sizes
ML-DSA-44: Use for TLS certificates requiring post-quantum security
ML-DSA-65: Use for message signatures with strong post-quantum security
ML-DSA-87: Use for high-security applications requiring maximum protection

§Examples

use zoe_wire_protocol::{VerifyingKey, SigningKey, KeyPair};
use rand::rngs::OsRng;

// Generate a keypair
let keypair = KeyPair::generate(&mut OsRng);
let verifying_key = keypair.public_key();

// Sign and verify a message
let message = b"Hello, world!";
let signature = keypair.sign(message);
let is_valid = verifying_key.verify(message, &signature)?;
assert!(is_valid);

Variants§

§

MlDsa44((Box<MLDSA44VerificationKey>, Hash))

ML-DSA-44 public key (1,312 bytes) - for TLS certificates

§

MlDsa65((Box<MLDSA65VerificationKey>, Hash))

ML-DSA-65 public key (1,952 bytes) - for message signatures

§

MlDsa87((Box<MLDSA87VerificationKey>, Hash))

ML-DSA-87 public key (2,592 bytes) - for high security

Implementations§

Source §

impl VerifyingKey

flutter_rust_bridge:opaque

Source

pub fn algorithm(&self) -> Algorithm

Get the algorithm for this key type

Source

pub fn verify( &self, message: &[u8], signature: &Signature, ) -> Result<(), VerifyError>

Verify a signature against a message using the appropriate algorithm.

This method automatically matches the signature type with the key type and returns Ok(false) if they don’t match (rather than an error).

§Arguments

message - The message bytes that were signed
signature - The signature to verify

§Returns

Ok(true) - Signature is valid for this key and message
Ok(false) - Signature is invalid or key/signature types don’t match
Err(_) - Verification error (malformed signature, etc.)

§Examples

use zoe_wire_protocol::{KeyPair, VerifyingKey, SigningKey};
use rand::rngs::OsRng;

let keypair = KeyPair::generate_ed25519(&mut OsRng);
let message = b"Hello, world!";
let signature = keypair.sign(message);
let verifying_key = keypair.public_key();

let is_valid = verifying_key.verify(message, &signature)?;
assert!(is_valid);

Source

pub fn encode(&self) -> Vec<u8> ⓘ

Encode the VerifyingKey to bytes for serialization.

This method serializes the key using postcard format for efficient storage and transmission. The resulting bytes can be deserialized back to a VerifyingKey using postcard::from_bytes().

§Returns

A Vec<u8> containing the serialized key data.

§Examples

use zoe_wire_protocol::{KeyPair, VerifyingKey};
use rand::rngs::OsRng;

let keypair = KeyPair::generate_ed25519(&mut OsRng);
let verifying_key = keypair.public_key();

// Serialize the key
let key_bytes = verifying_key.encode();

// Deserialize it back
let restored_key: VerifyingKey = postcard::from_bytes(&key_bytes).unwrap();
assert_eq!(&verifying_key, &restored_key);

Source

pub fn to_pem(&self) -> Result<String, VerifyingKeyError>

Export the VerifyingKey to PEM format.

This method serializes the key using postcard format and then encodes it as a PEM block with the label “ZOE PUBLIC KEY”. This provides a standardized text format that’s compatible with many cryptographic tools and libraries.

§Returns

A Result<String, VerifyingKeyError> containing the PEM-encoded key or an error.

§Examples

use zoe_wire_protocol::{KeyPair, VerifyingKey};
use rand::rngs::OsRng;

let keypair = KeyPair::generate_ed25519(&mut OsRng);
let verifying_key = keypair.public_key();
let pem_string = verifying_key.to_pem().unwrap();
println!("Public key PEM:\n{}", pem_string);

Source

pub fn from_pem(pem_string: &str) -> Result<VerifyingKey, VerifyingKeyError>

Import a VerifyingKey from PEM format.

This method parses a PEM-encoded string and deserializes it back to a VerifyingKey. The PEM block should have the label “ZOE PUBLIC KEY”.

§Arguments

pem_string - A string containing the PEM-encoded public key

§Returns

A Result<VerifyingKey, VerifyingKeyError> containing the decoded key or an error.

§Examples

use zoe_wire_protocol::{KeyPair, VerifyingKey};
use rand::rngs::OsRng;

let original_keypair = KeyPair::generate_ed25519(&mut OsRng);
let original_key = original_keypair.public_key();
let pem_string = original_key.to_pem().unwrap();

let restored_key = VerifyingKey::from_pem(&pem_string).unwrap();
assert_eq!(original_key.encode(), restored_key.encode());