use ed25519_dalek::{Signature, Signer as _, SigningKey, Verifier as _, VerifyingKey};
use thiserror::Error;
const DOMAIN: &[u8] = b"pub/v1/sig";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SigAlg {
Ed25519,
}
impl SigAlg {
#[must_use]
pub fn id(self) -> &'static str {
match self {
Self::Ed25519 => "ed25519",
}
}
#[must_use]
pub fn from_id(id: &str) -> Option<Self> {
match id {
"ed25519" => Some(Self::Ed25519),
_ => None,
}
}
}
#[derive(Debug, Error, PartialEq, Eq, Clone)]
#[non_exhaustive]
pub enum SigError {
#[error("unknown signature algorithm: {0}")]
UnknownAlgorithm(String),
#[error("malformed public key")]
MalformedKey,
#[error("malformed secret key")]
MalformedSecretKey,
#[error("malformed signature")]
MalformedSignature,
#[error("signature does not verify")]
BadSignature,
#[error("purpose mismatch: signature is for {found:?}, context requires {expected:?}")]
PurposeMismatch {
found: String,
expected: String,
},
#[error("purpose must not contain a NUL byte")]
PurposeContainsNul,
}
pub fn signing_message(purpose: &str, target_bytes: &[u8]) -> Result<Vec<u8>, SigError> {
if purpose.as_bytes().contains(&0) {
return Err(SigError::PurposeContainsNul);
}
let mut message = Vec::with_capacity(DOMAIN.len() + purpose.len() + target_bytes.len() + 2);
message.extend_from_slice(DOMAIN);
message.push(0);
message.extend_from_slice(purpose.as_bytes());
message.push(0);
message.extend_from_slice(target_bytes);
Ok(message)
}
pub fn verify(
alg: SigAlg,
public_key: &[u8],
signature: &[u8],
found_purpose: &str,
expected_purpose: &str,
target_bytes: &[u8],
) -> Result<(), SigError> {
if found_purpose != expected_purpose {
return Err(SigError::PurposeMismatch {
found: found_purpose.to_owned(),
expected: expected_purpose.to_owned(),
});
}
let message = signing_message(found_purpose, target_bytes)?;
match alg {
SigAlg::Ed25519 => {
let key_bytes: [u8; 32] = public_key.try_into().map_err(|_| SigError::MalformedKey)?;
let key = VerifyingKey::from_bytes(&key_bytes).map_err(|_| SigError::MalformedKey)?;
let sig_bytes: [u8; 64] = signature
.try_into()
.map_err(|_| SigError::MalformedSignature)?;
let sig = Signature::from_bytes(&sig_bytes);
key.verify(&message, &sig)
.map_err(|_| SigError::BadSignature)
}
}
}
pub fn sign(
alg: SigAlg,
secret_key: &[u8],
purpose: &str,
target_bytes: &[u8],
) -> Result<Vec<u8>, SigError> {
let message = signing_message(purpose, target_bytes)?;
match alg {
SigAlg::Ed25519 => {
let key_bytes: [u8; 32] = secret_key
.try_into()
.map_err(|_| SigError::MalformedSecretKey)?;
let signing_key = SigningKey::from_bytes(&key_bytes);
Ok(signing_key.sign(&message).to_bytes().to_vec())
}
}
}
pub fn verifying_key(alg: SigAlg, secret_key: &[u8]) -> Result<Vec<u8>, SigError> {
match alg {
SigAlg::Ed25519 => {
let key_bytes: [u8; 32] = secret_key
.try_into()
.map_err(|_| SigError::MalformedSecretKey)?;
let signing_key = SigningKey::from_bytes(&key_bytes);
Ok(signing_key.verifying_key().as_bytes().to_vec())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn key() -> SigningKey {
SigningKey::from_bytes(&[7u8; 32])
}
#[test]
fn verifies_a_correct_signature() {
let sk = key();
let target = b"canonical bytes";
let msg = signing_message("endorse", target).unwrap();
let sig = sk.sign(&msg);
assert!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
&sig.to_bytes(),
"endorse",
"endorse",
target,
)
.is_ok()
);
}
#[test]
fn rejects_a_signature_replayed_under_another_purpose() {
let sk = key();
let target = b"canonical bytes";
let msg = signing_message("endorse", target).unwrap();
let sig = sk.sign(&msg);
assert!(matches!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
&sig.to_bytes(),
"endorse",
"retract",
target,
),
Err(SigError::PurposeMismatch { .. })
));
assert!(matches!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
&sig.to_bytes(),
"retract",
"retract",
target,
),
Err(SigError::BadSignature)
));
}
#[test]
fn rejects_a_signature_over_different_bytes() {
let sk = key();
let msg = signing_message("endorse", b"original").unwrap();
let sig = sk.sign(&msg);
assert_eq!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
&sig.to_bytes(),
"endorse",
"endorse",
b"tampered",
),
Err(SigError::BadSignature)
);
}
#[test]
fn purposes_cannot_be_made_ambiguous() {
assert_eq!(
signing_message("a\0b", b""),
Err(SigError::PurposeContainsNul)
);
let x = signing_message("ab", b"c").unwrap();
let y = signing_message("a", b"bc").unwrap();
assert_ne!(x, y);
}
#[test]
fn rejects_malformed_inputs() {
let sk = key();
assert_eq!(
verify(SigAlg::Ed25519, b"short", &[0u8; 64], "p", "p", b""),
Err(SigError::MalformedKey)
);
assert_eq!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
b"short",
"p",
"p",
b""
),
Err(SigError::MalformedSignature)
);
}
#[test]
fn a_signature_this_module_produces_verifies_against_itself() {
let sk = key();
let target = b"canonical bytes";
let produced = sign(
SigAlg::Ed25519,
sk.to_bytes().as_slice(),
"authored",
target,
)
.unwrap();
assert!(
verify(
SigAlg::Ed25519,
sk.verifying_key().as_bytes(),
&produced,
"authored",
"authored",
target,
)
.is_ok()
);
}
#[test]
fn sign_rejects_a_malformed_secret_key() {
assert_eq!(
sign(SigAlg::Ed25519, b"short", "p", b""),
Err(SigError::MalformedSecretKey)
);
}
}