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"
}
}
#[cfg(target_arch = "wasm32")]
pub struct WebCryptoSigningProvider {
crypto_key: web_sys::CryptoKey,
verifying_key: [u8; 32],
}
#[cfg(target_arch = "wasm32")]
impl WebCryptoSigningProvider {
pub fn new() -> Result<Self, String> {
use std::cell::RefCell;
use std::rc::Rc;
use wasm_bindgen::JsCast;
use wasm_bindgen_futures::{spawn_local, JsFuture};
let window = web_sys::window().ok_or("no window object")?;
let crypto = window.crypto().map_err(|e| format!("get crypto: {:?}", e))?;
let subtle = crypto.subtle();
let algo = js_sys::Object::new();
js_sys::Reflect::set(&algo, &"name".into(), &"Ed25519".into())
.map_err(|e| format!("set algo name: {:?}", e))?;
let keygen_promise = subtle.generate_key_with_object(&algo, true, &js_sys::Array::new())
.map_err(|e| format!("generateKey: {:?}", e))?;
let result: Rc<RefCell<Option<Result<js_sys::Object, String>>>> = Rc::new(RefCell::new(None));
let result_clone = result.clone();
spawn_local(async move {
let keypair_result = JsFuture::from(keygen_promise).await;
match keypair_result {
Ok(keypair) => {
let obj = keypair.dyn_into::<js_sys::Object>()
.map_err(|_| "keypair is not an object".to_string());
*result_clone.borrow_mut() = Some(obj);
}
Err(e) => {
*result_clone.borrow_mut() = Some(Err(format!("generateKey future: {:?}", e)));
}
}
});
while result.borrow().is_none() {
}
let keypair_obj = result.borrow().clone()
.ok_or("spawn_local did not complete")?
.map_err(|e| e)?;
let public_key = js_sys::Reflect::get(&keypair_obj, &"publicKey".into())
.map_err(|e| format!("get publicKey: {:?}", e))?
.dyn_into::<web_sys::CryptoKey>()
.map_err(|_| "publicKey is not a CryptoKey".to_string())?;
let private_key = js_sys::Reflect::get(&keypair_obj, &"privateKey".into())
.map_err(|e| format!("get privateKey: {:?}", e))?
.dyn_into::<web_sys::CryptoKey>()
.map_err(|_| "privateKey is not a CryptoKey".to_string())?;
let export_promise = subtle.export_key("raw", &public_key)
.map_err(|e| format!("exportKey: {:?}", e))?;
let export_result: Rc<RefCell<Option<Result<js_sys::ArrayBuffer, String>>>> = Rc::new(RefCell::new(None));
let export_clone = export_result.clone();
spawn_local(async move {
let exported_result = JsFuture::from(export_promise).await;
match exported_result {
Ok(buf) => {
let ab = buf.dyn_into::<js_sys::ArrayBuffer>()
.map_err(|_| "exported key is not ArrayBuffer".to_string());
*export_clone.borrow_mut() = Some(ab);
}
Err(e) => {
*export_clone.borrow_mut() = Some(Err(format!("exportKey future: {:?}", e)));
}
}
});
while export_result.borrow().is_none() {}
let exported_buffer = export_result.borrow().clone()
.ok_or("export spawn_local did not complete")?
.map_err(|e| e)?;
let exported_bytes = js_sys::Uint8Array::new(&exported_buffer);
let mut vk_bytes = [0u8; 32];
if exported_bytes.length() != 32 {
return Err(format!("expected 32-byte public key, got {}", exported_bytes.length()));
}
exported_bytes.copy_to(&mut vk_bytes);
Ok(Self {
crypto_key: private_key,
verifying_key: vk_bytes,
})
}
}
#[cfg(target_arch = "wasm32")]
impl SigningProvider for WebCryptoSigningProvider {
fn sign(&self, message: &[u8]) -> Result<Vec<u8>, String> {
use std::cell::RefCell;
use std::rc::Rc;
use wasm_bindgen::JsCast;
use wasm_bindgen_futures::{spawn_local, JsFuture};
let window = web_sys::window().ok_or("no window object")?;
let crypto = window.crypto().map_err(|e| format!("get crypto: {:?}", e))?;
let subtle = crypto.subtle();
let algo = js_sys::Object::new();
js_sys::Reflect::set(&algo, &"name".into(), &"Ed25519".into())
.map_err(|e| format!("set algo: {:?}", e))?;
let data = js_sys::Uint8Array::from(message);
let sign_promise = subtle.sign_with_object_and_buffer_source(&algo, &self.crypto_key, &data)
.map_err(|e| format!("sign: {:?}", e))?;
let result: Rc<RefCell<Option<Result<js_sys::ArrayBuffer, String>>>> = Rc::new(RefCell::new(None));
let result_clone = result.clone();
spawn_local(async move {
let sign_result = JsFuture::from(sign_promise).await;
match sign_result {
Ok(buf) => {
let ab = buf.dyn_into::<js_sys::ArrayBuffer>()
.map_err(|_| "signature is not ArrayBuffer".to_string());
*result_clone.borrow_mut() = Some(ab);
}
Err(e) => {
*result_clone.borrow_mut() = Some(Err(format!("sign future: {:?}", e)));
}
}
});
while result.borrow().is_none() {}
let sig_arraybuffer = result.borrow().clone()
.ok_or("sign spawn_local did not complete")?
.map_err(|e| e)?;
let sig_bytes = js_sys::Uint8Array::new(&sig_arraybuffer);
let mut sig = vec![0u8; sig_bytes.length() as usize];
sig_bytes.copy_to(&mut sig);
Ok(sig)
}
fn verifying_key_bytes(&self) -> [u8; 32] {
self.verifying_key
}
fn name(&self) -> &str {
"webcrypto"
}
}
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);
}
}