use ed25519_dalek::{Signature, SigningKey, Verifier, VerifyingKey};
pub trait SigningProvider: Send + Sync {
fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String>;
fn verifying_key_bytes(&self) -> [u8; 32];
fn name(&self) -> &str;
}
pub fn verify_signature(
verifying_key_bytes: &[u8; 32],
message: &[u8],
signature_bytes: &[u8],
) -> Result<bool, String> {
let verifying_key = VerifyingKey::from_bytes(verifying_key_bytes)
.map_err(|e| format!("invalid verifying key: {e}"))?;
let signature = Signature::from_slice(signature_bytes)
.map_err(|e| format!("invalid signature: {e}"))?;
Ok(verifying_key.verify(message, &signature).is_ok())
}
pub struct DalekSigningProvider {
signing_key: SigningKey,
verifying_key: VerifyingKey,
}
impl DalekSigningProvider {
pub fn generate() -> Self {
use rand::rngs::OsRng;
let signing_key = SigningKey::generate(&mut OsRng);
let verifying_key = signing_key.verifying_key();
Self {
signing_key,
verifying_key,
}
}
pub fn from_seed(seed: &[u8; 32]) -> Self {
let signing_key = SigningKey::from_bytes(seed);
let verifying_key = signing_key.verifying_key();
Self {
signing_key,
verifying_key,
}
}
pub fn verifying_key(&self) -> &VerifyingKey {
&self.verifying_key
}
}
impl SigningProvider for DalekSigningProvider {
fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String> {
use ed25519_dalek::Signer;
let sig: Signature = self.signing_key.sign(message);
Ok(sig.to_bytes().to_vec())
}
fn verifying_key_bytes(&self) -> [u8; 32] {
self.verifying_key.to_bytes()
}
fn name(&self) -> &str {
"dalek"
}
}
pub fn default_signing_provider() -> Box<dyn SigningProvider> {
Box::new(DalekSigningProvider::generate())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_dalek_sign_and_verify() {
let provider = DalekSigningProvider::generate();
let message = b"hello world";
let sig = provider.sign(message).unwrap();
let vk_bytes = provider.verifying_key_bytes();
let valid = verify_signature(&vk_bytes, message, &sig).unwrap();
assert!(valid);
}
#[test]
fn test_dalek_verify_rejects_tampered() {
let provider = DalekSigningProvider::generate();
let message = b"hello world";
let mut sig = provider.sign(message).unwrap();
sig[0] ^= 0xff;
let vk_bytes = provider.verifying_key_bytes();
let valid = verify_signature(&vk_bytes, message, &sig).unwrap();
assert!(!valid);
}
#[test]
fn test_dalek_from_seed_deterministic() {
let seed = [42u8; 32];
let p1 = DalekSigningProvider::from_seed(&seed);
let p2 = DalekSigningProvider::from_seed(&seed);
assert_eq!(p1.verifying_key_bytes(), p2.verifying_key_bytes());
let message = b"deterministic test";
let s1 = p1.sign(message).unwrap();
let s2 = p2.sign(message).unwrap();
assert_eq!(s1, s2);
}
#[test]
fn test_default_signing_provider() {
let provider = default_signing_provider();
assert_eq!(provider.name(), "dalek");
let message = b"default provider test";
let sig = provider.sign(message).unwrap();
let vk = provider.verifying_key_bytes();
assert!(verify_signature(&vk, message, &sig).unwrap());
}
#[test]
fn test_signing_provider_trait_object() {
let provider: Box<dyn SigningProvider> = Box::new(DalekSigningProvider::generate());
let message = b"trait object test";
let sig = provider.sign(message).unwrap();
assert_eq!(sig.len(), 64); let vk = provider.verifying_key_bytes();
assert_eq!(vk.len(), 32); }
#[test]
fn test_verify_rejects_wrong_key() {
let p1 = DalekSigningProvider::generate();
let p2 = DalekSigningProvider::generate();
let message = b"wrong key test";
let sig = p1.sign(message).unwrap();
let wrong_vk = p2.verifying_key_bytes();
let valid = verify_signature(&wrong_vk, message, &sig).unwrap();
assert!(!valid);
}
}