use base64::Engine as _;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use ed25519_dalek::{Signature, Signer};
use http::Method;
pub use ed25519_dalek::{SigningKey as DalekSigningKey, VerifyingKey as DalekVerifyingKey};
pub const PARAM_TIMESTAMP: &str = "os_timestamp";
pub const PARAM_DURATION: &str = "os_duration";
pub const PARAM_KID: &str = "os_kid";
pub const PARAM_SIG: &str = "os_sig";
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum Error {
#[error("invalid key")]
InvalidKey,
#[error("invalid signature encoding")]
InvalidSignatureEncoding,
#[error("signature verification failed")]
VerificationFailed,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CanonicalRequest(String);
pub type SigningKey = [u8; 32];
pub type VerifyingKey = [u8; 32];
impl CanonicalRequest {
pub fn new(method: &Method, path: &str, query: Option<&str>) -> Self {
let normalized_method = if *method == Method::HEAD {
String::from("GET")
} else {
method.as_str().to_uppercase()
};
let mut pairs: Vec<String> = query
.unwrap_or_default()
.split('&')
.filter(|pair| !pair.is_empty())
.filter_map(|pair| {
if let Some((key, value)) = pair.split_once('=') {
let key = key.to_ascii_lowercase();
(key != PARAM_SIG).then(|| format!("{key}={value}"))
} else {
let key = pair.to_ascii_lowercase();
(key != PARAM_SIG).then_some(key)
}
})
.collect();
pairs.sort_unstable();
let canonical_query = pairs.join("&");
Self(format!("{normalized_method}\n{path}\n{canonical_query}"))
}
pub fn sign(&self, key: &SigningKey) -> String {
let key = DalekSigningKey::from_bytes(key);
let signature = key.sign(self.0.as_bytes());
URL_SAFE_NO_PAD.encode(signature.to_bytes())
}
pub fn verify(&self, key: &VerifyingKey, signature_b64: &str) -> Result<(), Error> {
let key = DalekVerifyingKey::from_bytes(key).map_err(|_| Error::InvalidKey)?;
let bytes = URL_SAFE_NO_PAD
.decode(signature_b64)
.map_err(|_| Error::InvalidSignatureEncoding)?;
let signature =
Signature::from_slice(&bytes).map_err(|_| Error::InvalidSignatureEncoding)?;
key.verify_strict(self.0.as_bytes(), &signature)
.map_err(|_| Error::VerificationFailed)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn test_signing_key() -> DalekSigningKey {
DalekSigningKey::from_bytes(&[0x42; 32])
}
fn sample_query() -> &'static str {
"os_timestamp=1985-04-12T23:20:50.52Z\
&os_kid=relay\
&os_duration=3600\
&os_sig=should-be-excluded"
}
#[test]
fn canonical_form_is_stable() {
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/org=17;project=42/foo/bar",
Some(sample_query()),
);
assert_eq!(
canonical.0,
"GET\n\
/v1/objects/testing/org=17;project=42/foo/bar\n\
os_duration=3600&\
os_kid=relay&\
os_timestamp=1985-04-12T23:20:50.52Z"
);
let canonical = CanonicalRequest::new(&Method::GET, "/v1/objects/testing/_/key", None);
assert_eq!(canonical.0, "GET\n/v1/objects/testing/_/key\n");
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some("dup=b&dup=a&x=1"),
);
assert_eq!(
canonical.0,
"GET\n/v1/objects/testing/_/key\ndup=a&dup=b&x=1"
);
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some(sample_query()),
);
assert_eq!(
canonical.0,
"GET\n\
/v1/objects/testing/_/key\n\
os_duration=3600&\
os_kid=relay&\
os_timestamp=1985-04-12T23:20:50.52Z"
);
}
#[test]
fn head_is_normalized_to_get() {
let path = "/v1/objects/testing/_/key";
assert_eq!(
CanonicalRequest::new(&Method::HEAD, path, Some(sample_query()),),
CanonicalRequest::new(&Method::GET, path, Some(sample_query()),),
);
}
#[test]
fn sign_and_verify_roundtrip() {
let sk = test_signing_key();
let vk = sk.verifying_key();
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some(sample_query()),
);
let signature = canonical.sign(sk.as_bytes());
assert_eq!(canonical.verify(vk.as_bytes(), &signature), Ok(()));
}
#[test]
fn verify_rejects_tampered_canonical() {
let sk = test_signing_key();
let vk = sk.verifying_key();
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some(sample_query()),
);
let signature = canonical.sign(sk.as_bytes());
let tampered = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/other",
Some(sample_query()),
);
assert_eq!(
tampered.verify(vk.as_bytes(), &signature),
Err(Error::VerificationFailed)
);
}
#[test]
fn verify_rejects_wrong_key() {
let sk = test_signing_key();
let other_vk = DalekSigningKey::from_bytes(&[0x01; 32]).verifying_key();
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some(sample_query()),
);
let signature = canonical.sign(sk.as_bytes());
assert_eq!(
canonical.verify(other_vk.as_bytes(), &signature),
Err(Error::VerificationFailed)
);
}
#[test]
fn verify_rejects_bad_signature_encoding() {
let vk = test_signing_key().verifying_key();
let canonical = CanonicalRequest::new(
&Method::GET,
"/v1/objects/testing/_/key",
Some(sample_query()),
);
assert_eq!(
canonical.verify(vk.as_bytes(), "not valid base64!!"),
Err(Error::InvalidSignatureEncoding)
);
assert_eq!(
canonical.verify(vk.as_bytes(), &URL_SAFE_NO_PAD.encode([0u8; 10])),
Err(Error::InvalidSignatureEncoding)
);
}
}