#![deny(clippy::unwrap_used, clippy::expect_used)]
use alloc::vec::Vec;
use crate::core::VerifyOptions;
use crate::core::crypto::verify_hmac_sha256;
use crate::core::error::VerifyError;
use crate::core::headers::HeaderMap;
use crate::core::secret::Secret;
pub(crate) const SIGNATURE_HEADER: &str = "linear-signature";
const SIGNATURE_LEN_BYTES: usize = 32;
pub(crate) fn verify(
headers: &dyn HeaderMap,
raw_body: &[u8],
secret: &Secret,
_options: &VerifyOptions,
) -> Result<(), VerifyError> {
let value = headers
.get(SIGNATURE_HEADER)
.ok_or(VerifyError::MissingHeader {
header: SIGNATURE_HEADER,
})?;
let provided = parse_signature(value)?;
if verify_hmac_sha256(secret.as_bytes(), raw_body, &provided) {
Ok(())
} else {
Err(VerifyError::SignatureMismatch)
}
}
fn parse_signature(value: &str) -> Result<Vec<u8>, VerifyError> {
if value.is_empty() {
return Err(VerifyError::MalformedHeader {
header: SIGNATURE_HEADER,
reason: "header is empty",
});
}
let bytes = hex::decode(value).map_err(|_| VerifyError::BadEncoding {
reason: "signature is not valid hexadecimal",
})?;
if bytes.len() != SIGNATURE_LEN_BYTES {
return Err(VerifyError::BadEncoding {
reason: "signature does not decode to 32 bytes",
});
}
Ok(bytes)
}
#[cfg(test)]
mod tests {
use super::SIGNATURE_HEADER;
use crate::core::error::VerifyError;
use crate::core::options::VerifyOptions;
use crate::core::secret::Secret;
use crate::verify;
use std::time::Duration;
const SECRET: &str = "test_secret_key";
const BODY: &[u8] = b"{\"action\":\"create\",\"type\":\"Issue\"}";
const SIGNATURE: &str = "d6fe7d87e27be0fa47a19aad05513445b414caae226a30677d7bdb9d78b836a0";
const EMPTY_BODY_SIGNATURE: &str =
"c1d7be015fcffd2d515199541faf4890f80f14b546b41ccc18bbe8573ab08b0a";
const UNICODE_BODY_SIGNATURE: &str =
"6fddeb6c7e9d5fa8a4d7d45ba7396f62d4524a01a230f9767b0c2d0351f9bf66";
fn linear_headers(signature: &str) -> Vec<(String, String)> {
vec![(SIGNATURE_HEADER.to_string(), signature.to_string())]
}
fn verify_with(body: &[u8], signature: &str) -> Result<(), VerifyError> {
verify(
crate::Provider::Linear,
&linear_headers(signature),
body,
&Secret::new(SECRET),
Default::default(),
)
}
#[test]
fn constructed_vector_verifies() {
assert_eq!(verify_with(BODY, SIGNATURE), Ok(()));
}
#[test]
fn boundary_bodies_verify() {
assert_eq!(verify_with(b"", EMPTY_BODY_SIGNATURE), Ok(()));
assert_eq!(
verify_with("héllo, 🦀 world!".as_bytes(), UNICODE_BODY_SIGNATURE),
Ok(())
);
}
#[test]
fn header_name_lookup_is_case_insensitive() {
let result = verify(
crate::Provider::Linear,
&[("Linear-Signature", SIGNATURE)],
BODY,
&Secret::new(SECRET),
Default::default(),
);
assert_eq!(result, Ok(()));
}
#[test]
fn negative_flipped_signature_byte_fails() {
let flipped = format!("{}0{}", &SIGNATURE[..10], &SIGNATURE[11..]);
assert_ne!(flipped, SIGNATURE);
assert_eq!(
verify_with(BODY, &flipped),
Err(VerifyError::SignatureMismatch)
);
}
#[test]
fn tampered_body_fails() {
assert_eq!(
verify_with(
b"{\"action\":\"create\",\"type\":\"Issue\",\"tampered\":true}",
SIGNATURE
),
Err(VerifyError::SignatureMismatch)
);
}
#[test]
fn wrong_secret_fails() {
let result = verify(
crate::Provider::Linear,
&linear_headers(SIGNATURE),
BODY,
&Secret::new("a different secret"),
Default::default(),
);
assert_eq!(result, Err(VerifyError::SignatureMismatch));
}
#[test]
fn max_age_has_no_effect_for_linear() {
let options = VerifyOptions {
max_age: Some(Duration::ZERO),
..VerifyOptions::default()
};
let result = verify(
crate::Provider::Linear,
&linear_headers(SIGNATURE),
BODY,
&Secret::new(SECRET),
options,
);
assert_eq!(result, Ok(()));
}
#[test]
fn missing_header_errors_distinctly() {
let result = verify(
crate::Provider::Linear,
&Vec::<(String, String)>::new(),
BODY,
&Secret::new(SECRET),
Default::default(),
);
assert_eq!(
result,
Err(VerifyError::MissingHeader {
header: SIGNATURE_HEADER
})
);
}
#[test]
fn malformed_and_bad_encoding_errors_are_distinct() {
let cases: &[(&str, VerifyError)] = &[
(
"",
VerifyError::MalformedHeader {
header: SIGNATURE_HEADER,
reason: "header is empty",
},
),
(
"not hex!!",
VerifyError::BadEncoding {
reason: "signature is not valid hexadecimal",
},
),
(
"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
VerifyError::BadEncoding {
reason: "signature does not decode to 32 bytes",
},
),
];
for &(value, expected) in cases {
let result = verify(
crate::Provider::Linear,
&[(SIGNATURE_HEADER, value)],
BODY,
&Secret::new(SECRET),
Default::default(),
);
assert_eq!(result, Err(expected), "input: {value:?}");
}
let value = "5257a869e7ecebeda32affa62cdca3fa51cad7e77a0e56ff536d0ce8e108d8b";
let result = verify(
crate::Provider::Linear,
&[(SIGNATURE_HEADER, value)],
BODY,
&Secret::new(SECRET),
Default::default(),
);
match result {
Err(VerifyError::BadEncoding { .. }) => {}
other => panic!("expected BadEncoding for {value:?}, got {other:?}"),
}
}
}