#![no_std]
#![forbid(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]
extern crate alloc;
mod keys;
pub use keys::{PrivateKey, PublicKey, Seed};
use curve25519_dalek::{
constants::ED25519_BASEPOINT_POINT, edwards::CompressedEdwardsY, scalar::Scalar,
traits::IsIdentity,
};
use sha2::{Digest, Sha512};
use subtle::ConstantTimeEq;
pub const SIGNATURE_LEN: usize = 48;
pub fn derive_keypair(seed: &Seed) -> (PrivateKey, PublicKey) {
let hash = Sha512::digest(seed.as_bytes());
let privkey_bytes = clamp(hash[..32].try_into().unwrap());
let priv_scalar = Scalar::from_bytes_mod_order(privkey_bytes);
let pubkey_bytes = (priv_scalar * ED25519_BASEPOINT_POINT)
.compress()
.to_bytes();
(PrivateKey::new(privkey_bytes), PublicKey::new(pubkey_bytes))
}
pub fn sign(privkey: &PrivateKey, pubkey: &PublicKey, msg: &[u8]) -> [u8; SIGNATURE_LEN] {
let nonce_hash = Sha512::new()
.chain_update(privkey.as_bytes())
.chain_update(msg)
.finalize();
let r = Scalar::from_bytes_mod_order_wide(&nonce_hash.into());
let r_bytes = (r * ED25519_BASEPOINT_POINT).compress().to_bytes();
let e_hash = Sha512::new()
.chain_update(r_bytes)
.chain_update(pubkey.as_bytes())
.chain_update(msg)
.finalize();
let e: [u8; 16] = e_hash[..16].try_into().unwrap();
let mut e_extended = [0u8; 32];
e_extended[..16].copy_from_slice(&e);
let e_scalar = Scalar::from_bytes_mod_order(e_extended);
let priv_scalar = Scalar::from_bytes_mod_order(*privkey.as_bytes());
let s = r + e_scalar * priv_scalar;
let mut sig = [0u8; SIGNATURE_LEN];
sig[..16].copy_from_slice(&e);
sig[16..].copy_from_slice(s.as_bytes());
sig
}
pub fn verify(pubkey: &PublicKey, msg: &[u8], sig: &[u8; SIGNATURE_LEN]) -> bool {
let e_received: [u8; 16] = sig[..16].try_into().unwrap();
let s_bytes: [u8; 32] = sig[16..].try_into().unwrap();
let s: Scalar = match Scalar::from_canonical_bytes(s_bytes).into() {
Some(s) => s,
None => return false,
};
if s == Scalar::ZERO {
return false;
}
let pubkey_point = match CompressedEdwardsY(*pubkey.as_bytes()).decompress() {
Some(p) if !p.is_identity() && p.is_torsion_free() => p,
_ => return false,
};
let mut e_extended = [0u8; 32];
e_extended[..16].copy_from_slice(&e_received);
let e_scalar = Scalar::from_bytes_mod_order(e_extended);
let sb = s * ED25519_BASEPOINT_POINT;
let epk = e_scalar * pubkey_point;
let r_prime = (sb - epk).compress();
let e_check = Sha512::new()
.chain_update(r_prime.as_bytes())
.chain_update(pubkey.as_bytes())
.chain_update(msg)
.finalize();
e_check[..16].ct_eq(&e_received).into()
}
fn clamp(mut bytes: [u8; 32]) -> [u8; 32] {
bytes[0] &= 248;
bytes[31] &= 127;
bytes[31] |= 64;
bytes
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(s: &str) -> alloc::vec::Vec<u8> {
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
.collect()
}
fn arr32(v: &[u8]) -> [u8; 32] {
v.try_into().expect("expected 32 bytes")
}
fn arr48(v: &[u8]) -> [u8; 48] {
v.try_into().expect("expected 48 bytes")
}
#[test]
fn derive_vector1() {
let seed = Seed::new(arr32(&hex(
"0000000000000000000000000000000000000000000000000000000000000000",
)));
let (priv_got, pub_got) = derive_keypair(&seed);
assert_eq!(
*priv_got.as_bytes(),
arr32(&hex("5046adc1dba838867b2bbbfdd0c3423e58b57970b5267a90f57960924a87f156"))
);
assert_eq!(
*pub_got.as_bytes(),
arr32(&hex("3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29"))
);
}
#[test]
fn derive_vector2() {
let seed = Seed::new(arr32(&hex(
"deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe",
)));
let (priv_got, pub_got) = derive_keypair(&seed);
assert_eq!(
*priv_got.as_bytes(),
arr32(&hex("50b8c29238a8403e0ac69e23d47b9184c371a92460d518351b099944bbdfa867"))
);
assert_eq!(
*pub_got.as_bytes(),
arr32(&hex("9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d"))
);
}
const VECTORS: &[(&str, &str, &str, &str)] = &[
(
"5046adc1dba838867b2bbbfdd0c3423e58b57970b5267a90f57960924a87f156",
"3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
"",
"26f70691bbde0c1e8becc00e7e7663cb6b72364b6ea208fdabef226c5b0d07cec9c661fd69671981ca40277598ea9c01",
),
(
"50b8c29238a8403e0ac69e23d47b9184c371a92460d518351b099944bbdfa867",
"9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
"74657374",
"c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009",
),
(
"b0829ce3ccf1d8edd5da1132d46271b0169f58b6414fd263d3c98da627170f5e",
"207a067892821e25d770f1fba0c47c11ff4b813e54162ece9eb839e076231ab6",
"54686520717569636b2062726f776e20666f78206a756d7073206f76657220746865206c617a7920646f67",
"e15b69ed5bd6fccc6c624431eb1bb08341ba571158da31249ac72a28af7f77ea0534b94cc1f8650dead98ccae16ec803",
),
];
#[test]
fn sign_matches_vectors() {
for (i, (privkey_hex, pubkey_hex, msg_hex, sig_hex)) in VECTORS.iter().enumerate() {
let privkey = PrivateKey::new(arr32(&hex(privkey_hex)));
let pubkey = PublicKey::new(arr32(&hex(pubkey_hex)));
let msg = hex(msg_hex);
let expected = hex(sig_hex);
let got = sign(&privkey, &pubkey, &msg);
assert_eq!(got.as_ref(), expected.as_slice(), "vector {i} sign mismatch");
}
}
#[test]
fn verify_valid_vectors() {
for (i, (_, pubkey_hex, msg_hex, sig_hex)) in VECTORS.iter().enumerate() {
let pubkey = PublicKey::new(arr32(&hex(pubkey_hex)));
let msg = hex(msg_hex);
let sig = arr48(&hex(sig_hex));
assert!(verify(&pubkey, &msg, &sig), "vector {i} verify rejected");
}
}
#[test]
fn invalid_wrong_message() {
let pubkey = PublicKey::new(arr32(&hex(
"9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
)));
let msg = hex("77726f6e67");
let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009"));
assert!(!verify(&pubkey, &msg, &sig));
}
#[test]
fn invalid_identity_point_pubkey() {
let pubkey = PublicKey::new(arr32(&hex(
"0100000000000000000000000000000000000000000000000000000000000000",
)));
let msg = hex("74657374");
let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009"));
assert!(!verify(&pubkey, &msg, &sig));
}
#[test]
fn invalid_zero_s() {
let pubkey = PublicKey::new(arr32(&hex(
"9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
)));
let msg = hex("74657374");
let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa030000000000000000000000000000000000000000000000000000000000000000"));
assert!(!verify(&pubkey, &msg, &sig));
}
#[test]
fn roundtrip() {
let seed = Seed::new([42u8; 32]);
let (privkey, pubkey) = derive_keypair(&seed);
let msg = b"test message";
let sig = sign(&privkey, &pubkey, msg);
assert!(verify(&pubkey, msg, &sig));
assert!(!verify(&pubkey, b"wrong", &sig));
}
}