use ed25519_dalek::{Signature, Verifier, VerifyingKey};
pub fn verify(
pubkey: &[u8; 32],
message: &[u8],
signature: &[u8],
) -> Result<(), crate::error::CryptoError> {
let verifying_key =
VerifyingKey::from_bytes(pubkey).map_err(|_| crate::error::CryptoError::InvalidKey)?;
let sig =
Signature::try_from(signature).map_err(|_| crate::error::CryptoError::InvalidSignature)?;
verifying_key
.verify(message, &sig)
.map_err(|_| crate::error::CryptoError::VerificationFailed)
}
pub fn key_id(ed25519_public_key_base64: &str) -> String {
use sha2::Digest as _;
let digest = sha2::Sha256::digest(ed25519_public_key_base64.as_bytes());
digest[..8].iter().map(|b| format!("{b:02x}")).collect()
}
pub fn public_key_from_base64(b64: &str) -> Result<[u8; 32], crate::error::CryptoError> {
use base64::Engine as _;
let bytes = base64::engine::general_purpose::STANDARD
.decode(b64)
.map_err(|_| crate::error::CryptoError::InvalidKey)?;
bytes
.try_into()
.map_err(|_| crate::error::CryptoError::InvalidKey)
}
#[cfg(test)]
mod tests {
use super::*;
use ed25519_dalek::{Signer, SigningKey};
use rand::rngs::OsRng;
use rand::RngCore;
fn gen_keypair() -> ([u8; 32], SigningKey) {
let mut secret = [0u8; 32];
OsRng.fill_bytes(&mut secret);
let signing_key = SigningKey::from_bytes(&secret);
(signing_key.verifying_key().to_bytes(), signing_key)
}
#[test]
fn accepts_a_valid_signature() {
let (pubkey, signing_key) = gen_keypair();
let message = b"the base64 enc string bytes";
let sig = signing_key.sign(message);
assert!(verify(&pubkey, message, &sig.to_bytes()).is_ok());
}
#[test]
fn rejects_tampered_message() {
let (pubkey, signing_key) = gen_keypair();
let sig = signing_key.sign(b"original");
assert!(verify(&pubkey, b"tampered!", &sig.to_bytes()).is_err());
}
#[test]
fn rejects_signature_from_a_different_key() {
let (pubkey_a, _) = gen_keypair();
let (_, signing_key_b) = gen_keypair();
let message = b"data";
let sig = signing_key_b.sign(message);
assert!(verify(&pubkey_a, message, &sig.to_bytes()).is_err());
}
#[test]
fn rejects_malformed_signature_bytes() {
let (pubkey, _) = gen_keypair();
assert!(verify(&pubkey, b"data", b"too-short").is_err());
}
#[test]
fn public_key_from_base64_round_trips() {
let (pubkey, _) = gen_keypair();
use base64::Engine as _;
let b64 = base64::engine::general_purpose::STANDARD.encode(pubkey);
assert_eq!(public_key_from_base64(&b64).unwrap(), pubkey);
}
#[test]
fn public_key_from_base64_rejects_wrong_length() {
use base64::Engine as _;
let b64 = base64::engine::general_purpose::STANDARD.encode(b"too short");
assert!(public_key_from_base64(&b64).is_err());
}
#[test]
fn key_id_matches_the_servers_own_vectors() {
let all_zero_key_b64 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
let kid = key_id(all_zero_key_b64);
assert_eq!(kid, "51643eac9777b63a");
assert_eq!(kid.len(), 16);
assert!(kid
.chars()
.all(|c| c.is_ascii_hexdigit() && !c.is_uppercase()));
}
#[test]
fn key_id_of_the_empty_string_is_the_unbackfilled_account_sentinel() {
assert_eq!(key_id(""), "e3b0c44298fc1c14");
}
#[test]
fn key_id_hashes_the_base64_string_not_the_decoded_bytes() {
use base64::Engine as _;
let (pubkey, _) = gen_keypair();
let b64 = base64::engine::general_purpose::STANDARD.encode(pubkey);
use sha2::Digest as _;
let over_decoded_bytes: String = sha2::Sha256::digest(pubkey)[..8]
.iter()
.map(|b| format!("{b:02x}"))
.collect();
assert_ne!(key_id(&b64), over_decoded_bytes);
}
}