use ed25519_dalek::{Signature, Verifier, VerifyingKey};
use hmac::{Hmac, KeyInit, Mac};
use sha1::Sha1;
use sha2::{Sha256, Sha512};
use subtle::ConstantTimeEq;
#[cfg(feature = "sendgrid")]
use p256::ecdsa::signature::hazmat::PrehashVerifier;
#[cfg(feature = "sendgrid")]
use p256::ecdsa::{Signature as EcdsaSignature, VerifyingKey as EcdsaVerifyingKey};
#[cfg(feature = "sendgrid")]
use p256::pkcs8::DecodePublicKey;
#[cfg(feature = "sendgrid")]
use sha2::Digest;
#[cfg(feature = "paypal")]
use crate::core::error::VerifyError;
#[cfg(feature = "paypal")]
use rsa::pkcs1v15::{Signature as RsaSignature, VerifyingKey as RsaVerifyingKey};
#[cfg(feature = "paypal")]
use rsa::RsaPublicKey;
#[cfg(feature = "paypal")]
use rsa::pkcs8::DecodePublicKey as RsaDecodePublicKey;
#[cfg(feature = "paypal")]
use rsa::sha2::Sha256 as RsaSha256;
#[cfg(feature = "paypal")]
use rsa::signature::Verifier as RsaSignatureVerifier;
#[cfg(feature = "paypal")]
use rsa::traits::PublicKeyParts as RsaPublicKeyParts;
type HmacSha256 = Hmac<Sha256>;
type HmacSha1 = Hmac<Sha1>;
type HmacSha512 = Hmac<Sha512>;
const ED25519_KEY_LEN: usize = 32;
const ED25519_SIG_LEN: usize = 64;
#[must_use]
pub(crate) fn verify_hmac_sha256(
key: &[u8],
signed_string: &[u8],
provided_signature: &[u8],
) -> bool {
let mut mac = match HmacSha256::new_from_slice(key) {
Ok(mac) => mac,
Err(_) => return false,
};
mac.update(signed_string);
let expected = mac.finalize().into_bytes();
expected.as_slice().ct_eq(provided_signature).into()
}
#[must_use]
pub(crate) fn verify_hmac_sha1(
key: &[u8],
signed_string: &[u8],
provided_signature: &[u8],
) -> bool {
let mut mac = match HmacSha1::new_from_slice(key) {
Ok(mac) => mac,
Err(_) => return false,
};
mac.update(signed_string);
let expected = mac.finalize().into_bytes();
expected.as_slice().ct_eq(provided_signature).into()
}
#[must_use]
pub(crate) fn verify_hmac_sha512(
key: &[u8],
signed_string: &[u8],
provided_signature: &[u8],
) -> bool {
let mut mac = match HmacSha512::new_from_slice(key) {
Ok(mac) => mac,
Err(_) => return false,
};
mac.update(signed_string);
let expected = mac.finalize().into_bytes();
expected.as_slice().ct_eq(provided_signature).into()
}
#[must_use]
pub(crate) fn verify_ed25519(public_key: &[u8], message: &[u8], signature: &[u8]) -> bool {
let key_bytes = match <[u8; ED25519_KEY_LEN]>::try_from(public_key) {
Ok(bytes) => bytes,
Err(_) => return false,
};
let verifying_key = match VerifyingKey::from_bytes(&key_bytes) {
Ok(key) => key,
Err(_) => return false,
};
if signature.len() != ED25519_SIG_LEN {
return false;
}
match Signature::from_slice(signature) {
Ok(sig) => verifying_key.verify(message, &sig).is_ok(),
Err(_) => false,
}
}
#[cfg(feature = "sendgrid")]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum EcdsaP256Check {
Verified,
BadKey,
BadSignature,
Mismatch,
}
#[cfg(feature = "sendgrid")]
pub(crate) fn check_ecdsa_p256(
verifying_key_spki: &[u8],
message: &[u8],
signature_der: &[u8],
) -> EcdsaP256Check {
let verifying_key = match EcdsaVerifyingKey::from_public_key_der(verifying_key_spki) {
Ok(key) => key,
Err(_) => return EcdsaP256Check::BadKey,
};
let signature = match EcdsaSignature::from_der(signature_der) {
Ok(sig) => sig,
Err(_) => return EcdsaP256Check::BadSignature,
};
let mut hasher = Sha256::new();
hasher.update(message);
let digest = hasher.finalize();
if verifying_key.verify_prehash(&digest, &signature).is_err() {
return EcdsaP256Check::Mismatch;
}
EcdsaP256Check::Verified
}
#[cfg(feature = "paypal")]
#[must_use]
pub(crate) fn crc32_body(raw_body: &[u8]) -> u32 {
crc32fast::hash(raw_body)
}
#[cfg(feature = "paypal")]
pub(crate) fn extract_rsa_pubkey_from_x509(cert_bytes: &[u8]) -> Result<RsaPublicKey, VerifyError> {
let invalid = || VerifyError::InvalidSecret {
reason: "certificate is not a valid X.509 certificate",
};
let subject_spki: alloc::vec::Vec<u8> = if let Ok(x509) =
x509_parser::parse_x509_certificate(cert_bytes)
{
if !x509.0.is_empty() {
return Err(invalid());
}
x509.1.public_key().raw.to_vec()
} else if let Ok(pem) = x509_parser::pem::parse_x509_pem(cert_bytes) {
if pem.1.label != "CERTIFICATE" {
return Err(invalid());
}
if !pem.0.iter().all(u8::is_ascii_whitespace) {
return Err(invalid());
}
let x509 = x509_parser::parse_x509_certificate(&pem.1.contents).map_err(|_| invalid())?;
if !x509.0.is_empty() {
return Err(invalid());
}
x509.1.public_key().raw.to_vec()
} else {
return Err(invalid());
};
RsaPublicKey::from_public_key_der(&subject_spki).map_err(|_| VerifyError::InvalidSecret {
reason: "certificate does not contain an RSA public key",
})
}
#[cfg(feature = "paypal")]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum RsaSha256Check {
Verified,
BadSignature,
Mismatch,
}
#[cfg(feature = "paypal")]
pub(crate) fn check_rsa_pkcs1v15_sha256(
public_key: &RsaPublicKey,
message: &[u8],
signature: &[u8],
) -> RsaSha256Check {
if signature.len() != RsaPublicKeyParts::size(public_key) {
return RsaSha256Check::BadSignature;
}
let verifying_key = RsaVerifyingKey::<RsaSha256>::new(public_key.clone());
let signature = match RsaSignature::try_from(signature) {
Ok(sig) => sig,
Err(_) => return RsaSha256Check::BadSignature,
};
if RsaSignatureVerifier::verify(&verifying_key, message, &signature).is_err() {
return RsaSha256Check::Mismatch;
}
RsaSha256Check::Verified
}
#[cfg(test)]
mod tests {
use super::{verify_ed25519, verify_hmac_sha1, verify_hmac_sha256, verify_hmac_sha512};
fn decode(vector: &str) -> Vec<u8> {
match hex::decode(vector) {
Ok(bytes) => bytes,
Err(_) => panic!("hardcoded test vectors must be valid hex"),
}
}
#[test]
fn matches_known_vector() {
let key = b"Jefe";
let data = b"what do ya want for nothing?";
let sig = decode("5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
assert!(verify_hmac_sha256(key, data, &sig));
}
#[test]
fn hmac_sha1_matches_rfc2202_vector() {
let sig = decode("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79");
assert!(verify_hmac_sha1(
b"Jefe",
b"what do ya want for nothing?",
&sig
));
}
#[test]
fn rejects_tampered_and_wrong_length() {
let sig = decode("5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
let mut flipped = sig.clone();
flipped[0] ^= 0x01;
assert!(!verify_hmac_sha256(
b"Jefe",
b"what do ya want for nothing?",
&flipped
));
assert!(!verify_hmac_sha256(
b"Jefe",
b"what do ya want for nothing?",
&sig[..31]
));
assert!(!verify_hmac_sha256(
b"wrong key",
b"what do ya want for nothing?",
&sig
));
}
#[test]
fn hmac_sha1_rejects_tampered_and_wrong_length() {
let sig = decode("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79");
let mut flipped = sig.clone();
flipped[0] ^= 0x01;
assert!(!verify_hmac_sha1(
b"Jefe",
b"what do ya want for nothing?",
&flipped
));
assert!(!verify_hmac_sha1(
b"Jefe",
b"what do ya want for nothing?",
&sig[..19]
));
}
#[test]
fn hmac_sha512_matches_rfc4231_vector() {
let sig = decode(
"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
);
assert!(verify_hmac_sha512(
b"Jefe",
b"what do ya want for nothing?",
&sig
));
}
#[test]
fn hmac_sha512_rejects_tampered_and_wrong_length() {
let sig = decode(
"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
);
let mut flipped = sig.clone();
flipped[0] ^= 0x01;
assert!(!verify_hmac_sha512(
b"Jefe",
b"what do ya want for nothing?",
&flipped
));
assert!(!verify_hmac_sha512(
b"Jefe",
b"what do ya want for nothing?",
&sig[..63]
));
}
fn sign_with_seed(seed: [u8; 32], message: &[u8]) -> ([u8; 32], Vec<u8>) {
use ed25519_dalek::Signer;
let signing_key = ed25519_dalek::SigningKey::from_bytes(&seed);
let verifying_key = signing_key.verifying_key();
let sig = signing_key.sign(message);
(*verifying_key.as_bytes(), sig.to_bytes().to_vec())
}
#[test]
fn ed25519_verifies_genuine_signature() {
let (public_key, signature) = sign_with_seed([7u8; 32], b"hello");
assert!(verify_ed25519(&public_key, b"hello", &signature));
}
#[test]
fn ed25519_rejects_tampered_malformed_and_wrong_key() {
let (public_key, signature) = sign_with_seed([7u8; 32], b"hello");
assert!(!verify_ed25519(&public_key, b"hellO", &signature));
let mut flipped = signature.clone();
flipped[0] ^= 0x01;
assert!(!verify_ed25519(&public_key, b"hello", &flipped));
assert!(!verify_ed25519(&public_key, b"hello", &signature[..63]));
let mut padded = signature.clone();
padded.push(0);
assert!(!verify_ed25519(&public_key, b"hello", &padded));
assert!(!verify_ed25519(&public_key[..31], b"hello", &signature));
let bad_point = [0xffu8; 32];
assert!(!verify_ed25519(&bad_point, b"hello", &signature));
let (other_key, _) = sign_with_seed([8u8; 32], b"hello");
assert!(!verify_ed25519(&other_key, b"hello", &signature));
assert!(!verify_ed25519(b"", b"hello", &signature));
assert!(!verify_ed25519(&public_key, b"", &[]));
}
#[cfg(feature = "paypal")]
mod paypal {
use super::super::{check_rsa_pkcs1v15_sha256, crc32_body, extract_rsa_pubkey_from_x509};
use crate::core::crypto::RsaSha256Check;
use crate::core::error::VerifyError;
use crate::core::secret::Secret;
use crate::test_helpers::clocked_at;
use crate::verify;
use base64::Engine;
use std::time::Duration;
const TRANSMISSION_ID: &str = "db49fb10-1343-11ef-ac58-e32457403f67";
const TRANSMISSION_TIME: &str = "2024-05-16T05:19:23Z";
const WEBHOOK_ID: &str = "0NH55953DH663215D";
const CRC32_DECIMAL: u32 = 1_529_064_350;
const SIGNATURE_B64: &str = "aGYe/s6lwrASh2zyTRIAz8Edo705ezMKekirejT08ev3VXdWAkq4JWADiNPUGelx5qrEKxC7mPIHmAwQ5hOT6unhY9n33M/DbXTKGsuITPdXRA7qYVmc2wsIp68BpzB6pC6+5vt/YLQvflsrwrutGa0KyZc5FinuYNN8pTNomv4uiygasWqfnDyKViKQPNZecowag6tY/9pj7+bgBu/joBpYUq0+cQxfGqNnlvywBJ7HCOf4edeTIvM/c1CvvAHGtNTU54kLjWGue640twn6iXPL8tnaABZ8Fr9m0z87v8oY0vBobERV0Yu8thUToKhvQEFF26Rckqy07VVddg1CmA==";
const CERT_PEM: &[u8] = include_bytes!("../../tests/data/paypal_test_cert.pem");
const OTHER_CERT_PEM: &[u8] = include_bytes!("../../tests/data/paypal_other_cert.pem");
const BODY: &[u8] = include_bytes!("../../tests/data/paypal_docs_body.json");
fn signature_bytes() -> Vec<u8> {
match base64::engine::general_purpose::STANDARD.decode(SIGNATURE_B64) {
Ok(bytes) => bytes,
Err(_) => panic!("test-vector base64 must decode"),
}
}
fn signed_message() -> Vec<u8> {
format!("{TRANSMISSION_ID}|{TRANSMISSION_TIME}|{WEBHOOK_ID}|{CRC32_DECIMAL}")
.into_bytes()
}
fn rsa_key() -> rsa::RsaPublicKey {
match extract_rsa_pubkey_from_x509(CERT_PEM) {
Ok(key) => key,
Err(_) => panic!("the committed test certificate must parse"),
}
}
#[test]
fn crc32_body_matches_independently_computed_vector() {
assert_eq!(crc32_body(BODY), CRC32_DECIMAL);
}
#[test]
fn crc32_body_is_over_raw_bytes_and_is_deterministic() {
assert_eq!(crc32_body(b"{}"), crc32_body(b"{}"));
assert_ne!(crc32_body(b"{}"), crc32_body(b"{ }"));
assert_ne!(crc32_body(BODY), crc32_body(b""));
}
#[test]
fn extract_pubkey_accepts_pem_and_der() {
let from_pem = match extract_rsa_pubkey_from_x509(CERT_PEM) {
Ok(key) => key,
Err(_) => panic!("PEM certificate must parse"),
};
let pem = match x509_parser::pem::parse_x509_pem(CERT_PEM) {
Ok((_, pem)) => pem,
Err(_) => panic!("PEM must parse"),
};
let from_der = match extract_rsa_pubkey_from_x509(&pem.contents) {
Ok(key) => key,
Err(_) => panic!("DER certificate must parse"),
};
assert_eq!(from_pem, from_der);
}
#[test]
fn extract_pubkey_fails_closed_on_garbage() {
assert_eq!(
extract_rsa_pubkey_from_x509(b"definitely not a certificate"),
Err(VerifyError::InvalidSecret {
reason: "certificate is not a valid X.509 certificate"
})
);
assert_eq!(
extract_rsa_pubkey_from_x509(b""),
Err(VerifyError::InvalidSecret {
reason: "certificate is not a valid X.509 certificate"
})
);
let pem = match x509_parser::pem::parse_x509_pem(CERT_PEM) {
Ok((_, pem)) => pem,
Err(_) => panic!("PEM must parse"),
};
let mut der_with_garbage = pem.contents;
der_with_garbage.push(0xde);
assert!(matches!(
extract_rsa_pubkey_from_x509(&der_with_garbage),
Err(VerifyError::InvalidSecret { .. })
));
}
#[test]
fn check_rsa_verifies_the_frozen_vector() {
let key = rsa_key();
let msg = signed_message();
let sig = signature_bytes();
assert_eq!(
check_rsa_pkcs1v15_sha256(&key, &msg, &sig),
RsaSha256Check::Verified
);
}
#[test]
fn check_rsa_classifies_wrong_length_signature() {
let key = rsa_key();
let msg = signed_message();
let sig = signature_bytes();
assert_eq!(
check_rsa_pkcs1v15_sha256(&key, &msg, &sig[..sig.len() - 1]),
RsaSha256Check::BadSignature
);
assert_eq!(
check_rsa_pkcs1v15_sha256(&key, &msg, &[]),
RsaSha256Check::BadSignature
);
}
#[test]
fn check_rsa_rejects_tampered_message_and_wrong_key() {
let key = rsa_key();
let other_key = match extract_rsa_pubkey_from_x509(OTHER_CERT_PEM) {
Ok(key) => key,
Err(_) => panic!("the committed other certificate must parse"),
};
let msg = signed_message();
let sig = signature_bytes();
let mut flipped = sig.clone();
flipped[0] ^= 0x01;
assert_eq!(
check_rsa_pkcs1v15_sha256(&key, &msg, &flipped),
RsaSha256Check::Mismatch
);
let mut tampered = msg.clone();
tampered[0] = if tampered[0] == b'd' { b'D' } else { b'd' };
assert_eq!(
check_rsa_pkcs1v15_sha256(&key, &tampered, &sig),
RsaSha256Check::Mismatch
);
assert_eq!(
check_rsa_pkcs1v15_sha256(&other_key, &msg, &sig),
RsaSha256Check::Mismatch
);
}
#[test]
fn full_pipeline_verifies_the_official_construction() {
let options = clocked_at(1_715_836_763, Some(Duration::from_secs(300)))
.with_webhook_id(WEBHOOK_ID)
.with_verifying_material(
crate::core::options::VerifyingKeyMaterial::X509Certificate(CERT_PEM.to_vec()),
);
let headers = [
("PayPal-Transmission-Id", TRANSMISSION_ID),
("PayPal-Transmission-Time", TRANSMISSION_TIME),
("PayPal-Transmission-Sig", SIGNATURE_B64),
("PayPal-Cert-Url", "https://example.invalid/cert"),
("PayPal-Auth-Algo", "SHA256withRSA"),
];
assert_eq!(
verify(
crate::Provider::PayPal,
&headers,
BODY,
&Secret::new("unused"),
options,
),
Ok(())
);
}
}
}