use std::collections::HashMap;
use std::future::Future;
use std::sync::{Arc, Mutex};
use std::time::{Duration as StdDuration, Instant};
use chrono::{DateTime, Utc};
use futures_util::StreamExt;
use lapin::Channel;
use lapin::options::{BasicAckOptions, BasicConsumeOptions, BasicNackOptions, QueueDeclareOptions};
use lapin::types::FieldTable;
use crate::amqp::hmac::verify_payload;
use crate::amqp::transport::{AmqpTlsConfig, connect_amqps};
use crate::error::AxiamError;
use crate::sensitive::Sensitive;
pub(crate) const MIN_ACCEPTED_KEY_VERSION: u8 = 2;
pub(crate) const DEFAULT_FRESHNESS_SKEW_SECS: i64 = 300;
struct ReplayFields {
key_version: u8,
nonce: String,
issued_at: DateTime<Utc>,
}
fn extract_replay_fields(body: &serde_json::Value) -> Option<ReplayFields> {
let key_version = u8::try_from(body.get("key_version")?.as_u64()?).ok()?;
let nonce = body.get("nonce")?.as_str()?.to_owned();
let issued_at = DateTime::parse_from_rfc3339(body.get("issued_at")?.as_str()?)
.ok()?
.with_timezone(&Utc);
Some(ReplayFields {
key_version,
nonce,
issued_at,
})
}
pub(crate) struct ReplayGuard {
skew: chrono::Duration,
seen: Mutex<HashMap<String, Instant>>,
}
impl ReplayGuard {
pub(crate) fn new(skew: chrono::Duration) -> Self {
Self {
skew,
seen: Mutex::new(HashMap::new()),
}
}
pub(crate) fn with_default_skew() -> Self {
Self::new(chrono::Duration::seconds(DEFAULT_FRESHNESS_SKEW_SECS))
}
fn ttl(&self) -> StdDuration {
(self.skew * 2)
.to_std()
.unwrap_or_else(|_| StdDuration::from_secs(DEFAULT_FRESHNESS_SKEW_SECS as u64 * 2))
}
pub(crate) fn is_fresh(&self, issued_at: DateTime<Utc>, now: DateTime<Utc>) -> bool {
now.signed_duration_since(issued_at).abs() <= self.skew
}
pub(crate) fn check_and_record_nonce(&self, nonce: &str) -> bool {
let ttl = self.ttl();
let now = Instant::now();
let mut seen = match self.seen.lock() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
seen.retain(|_, expiry| *expiry > now);
if seen.contains_key(nonce) {
return false;
}
seen.insert(nonce.to_owned(), now + ttl);
true
}
}
impl Default for ReplayGuard {
fn default() -> Self {
Self::with_default_skew()
}
}
fn validate_v2_replay_protection(
body: &serde_json::Value,
replay: &ReplayGuard,
) -> Result<(), &'static str> {
let fields = extract_replay_fields(body).ok_or(
"missing or malformed key_version/nonce/issued_at (NEW-4 v2 fields are mandatory)",
)?;
if fields.key_version < MIN_ACCEPTED_KEY_VERSION {
return Err("key_version below the minimum accepted version (NEW-4 hard cutover)");
}
if !replay.is_fresh(fields.issued_at, Utc::now()) {
return Err("issued_at outside the freshness skew window");
}
if !replay.check_and_record_nonce(&fields.nonce) {
return Err("nonce already seen (replay)");
}
Ok(())
}
pub(crate) trait AckableDelivery {
fn data(&self) -> &[u8];
fn ack(&self) -> impl Future<Output = ()> + Send;
fn nack(&self, requeue: bool) -> impl Future<Output = ()> + Send;
}
impl AckableDelivery for lapin::message::Delivery {
fn data(&self) -> &[u8] {
&self.data
}
async fn ack(&self) {
let _ = self.acker.ack(BasicAckOptions::default()).await;
}
async fn nack(&self, requeue: bool) {
let _ = self
.acker
.nack(BasicNackOptions {
requeue,
..Default::default()
})
.await;
}
}
pub(crate) async fn verify_and_dispatch<D, F, Fut>(
delivery: &D,
signing_key: &[u8],
handler: &F,
replay: &ReplayGuard,
) where
D: AckableDelivery,
F: Fn(serde_json::Value) -> Fut + Send + Sync,
Fut: Future<Output = ()> + Send,
{
let mut body: serde_json::Value = match serde_json::from_slice(delivery.data()) {
Ok(v) => v,
Err(_) => {
tracing::warn!(
target: "axiam_sdk::security",
"AMQP message body failed JSON parse; nacking without requeue"
);
delivery.nack(false).await;
return;
}
};
let sig = body
.get("hmac_signature")
.and_then(|v| v.as_str())
.map(str::to_owned);
if let Some(obj) = body.as_object_mut() {
obj.shift_remove("hmac_signature");
}
let canonical = match serde_json::to_vec(&body) {
Ok(bytes) => bytes,
Err(_) => {
tracing::warn!(
target: "axiam_sdk::security",
"AMQP message body failed to re-serialize for verification; nacking without requeue"
);
delivery.nack(false).await;
return;
}
};
let verified = match sig {
Some(ref s) => verify_payload(signing_key, &canonical, s),
None => false,
};
if !verified {
tracing::warn!(
target: "axiam_sdk::security",
"AMQP HMAC verification failed; nacking without requeue"
);
delivery.nack(false).await;
return;
}
if let Err(reason) = validate_v2_replay_protection(&body, replay) {
tracing::warn!(
target: "axiam_sdk::security",
reason,
"AMQP v2 replay-protection check failed; nacking without requeue"
);
delivery.nack(false).await;
return;
}
handler(body).await;
delivery.ack().await;
}
pub async fn consume<F, Fut>(
amqp_url: &str,
queue: &str,
signing_key: Sensitive<Vec<u8>>,
freshness_skew: Option<StdDuration>,
handler: F,
) -> Result<(), AxiamError>
where
F: Fn(serde_json::Value) -> Fut + Send + Sync + 'static,
Fut: Future<Output = ()> + Send,
{
consume_with_tls(
amqp_url,
queue,
signing_key,
freshness_skew,
&AmqpTlsConfig::default(),
handler,
)
.await
}
pub async fn consume_with_tls<F, Fut>(
amqp_url: &str,
queue: &str,
signing_key: Sensitive<Vec<u8>>,
freshness_skew: Option<StdDuration>,
tls: &AmqpTlsConfig,
handler: F,
) -> Result<(), AxiamError>
where
F: Fn(serde_json::Value) -> Fut + Send + Sync + 'static,
Fut: Future<Output = ()> + Send,
{
let connection = connect_amqps(amqp_url, tls).await?;
let channel: Channel = connection
.create_channel()
.await
.map_err(|e| AxiamError::Network {
message: format!("failed to create AMQP channel: {e}"),
source: None,
})?;
channel
.queue_declare(
queue.into(),
QueueDeclareOptions {
durable: true,
..Default::default()
},
FieldTable::default(),
)
.await
.map_err(|e| AxiamError::Network {
message: format!("failed to declare AMQP queue: {e}"),
source: None,
})?;
let mut consumer = channel
.basic_consume(
queue.into(),
"axiam-sdk-consumer".into(),
BasicConsumeOptions::default(),
FieldTable::default(),
)
.await
.map_err(|e| AxiamError::Network {
message: format!("failed to start AMQP consumer: {e}"),
source: None,
})?;
let key = Arc::new(signing_key);
let handler = Arc::new(handler);
let replay = Arc::new(
freshness_skew
.and_then(|skew| chrono::Duration::from_std(skew).ok())
.map(ReplayGuard::new)
.unwrap_or_default(),
);
while let Some(delivery_result) = consumer.next().await {
match delivery_result {
Ok(delivery) => {
let key = Arc::clone(&key);
let handler = Arc::clone(&handler);
let replay = Arc::clone(&replay);
verify_and_dispatch(&delivery, key.expose(), handler.as_ref(), replay.as_ref())
.await;
}
Err(e) => {
tracing::warn!(target: "axiam_sdk::security", error = %e, "AMQP consumer stream error");
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use crate::amqp::hmac::sign_payload;
#[derive(Clone)]
struct RecordingDelivery {
data: Vec<u8>,
acked: Arc<AtomicUsize>,
nacked_requeue_true: Arc<AtomicUsize>,
nacked_requeue_false: Arc<AtomicUsize>,
}
impl RecordingDelivery {
fn new(data: Vec<u8>) -> Self {
Self {
data,
acked: Arc::new(AtomicUsize::new(0)),
nacked_requeue_true: Arc::new(AtomicUsize::new(0)),
nacked_requeue_false: Arc::new(AtomicUsize::new(0)),
}
}
}
impl AckableDelivery for RecordingDelivery {
fn data(&self) -> &[u8] {
&self.data
}
async fn ack(&self) {
self.acked.fetch_add(1, Ordering::SeqCst);
}
async fn nack(&self, requeue: bool) {
if requeue {
self.nacked_requeue_true.fetch_add(1, Ordering::SeqCst);
} else {
self.nacked_requeue_false.fetch_add(1, Ordering::SeqCst);
}
}
}
use crate::amqp::test_log::{THREAD_EVENTS, init_recording_subscriber};
fn v2_body(key_version: u8, nonce: &str, issued_at: DateTime<Utc>) -> serde_json::Value {
serde_json::json!({
"correlation_id": "00000000-0000-0000-0000-000000000000",
"action": "read",
"key_version": key_version,
"nonce": nonce,
"issued_at": issued_at.to_rfc3339(),
})
}
fn make_signed_body_with(
key_version: u8,
nonce: &str,
issued_at: DateTime<Utc>,
) -> (serde_json::Value, Vec<u8>) {
let key = b"consumer-test-signing-key";
let mut body = v2_body(key_version, nonce, issued_at);
let canonical = serde_json::to_vec(&body).unwrap();
let sig = sign_payload(key, &canonical);
body.as_object_mut()
.unwrap()
.insert("hmac_signature".into(), serde_json::Value::String(sig));
let data = serde_json::to_vec(&body).unwrap();
(body, data)
}
fn make_signed_body() -> (serde_json::Value, Vec<u8>) {
make_signed_body_with(2, &uuid::Uuid::new_v4().to_string(), Utc::now())
}
#[tokio::test]
async fn valid_signature_invokes_handler_once_then_acks() {
let key = b"consumer-test-signing-key";
let (_body, data) = make_signed_body();
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(handler_calls.load(Ordering::SeqCst), 1);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 0);
assert_eq!(delivery.nacked_requeue_true.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn mismatched_signature_never_invokes_handler_and_nacks_without_requeue() {
let key = b"consumer-test-signing-key";
let (mut body, _data) = make_signed_body();
body.as_object_mut().unwrap().insert(
"hmac_signature".into(),
serde_json::Value::String(
"0000000000000000000000000000000000000000000000000000000000000000".into(),
),
);
let data = serde_json::to_vec(&body).unwrap();
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
0,
"handler must never be invoked on a tampered/mismatched signature"
);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_true.load(Ordering::SeqCst), 0);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn missing_signature_strict_mode_default_never_invokes_handler_and_nacks_without_requeue()
{
let key = b"consumer-test-signing-key";
let body = v2_body(2, &uuid::Uuid::new_v4().to_string(), Utc::now());
let data = serde_json::to_vec(&body).unwrap();
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
0,
"a delivery with no hmac_signature must be rejected in strict mode (the default)"
);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_true.load(Ordering::SeqCst), 0);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn invalid_json_body_never_invokes_handler_and_nacks_without_requeue() {
let key = b"consumer-test-signing-key";
let delivery = RecordingDelivery::new(b"not valid json {{{".to_vec());
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(handler_calls.load(Ordering::SeqCst), 0);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_true.load(Ordering::SeqCst), 0);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn security_event_log_omits_hmac_value() {
init_recording_subscriber();
let key = b"consumer-test-signing-key";
let (mut body, _data) = make_signed_body();
let leaked_signature_would_be = body
.get("hmac_signature")
.and_then(|v| v.as_str())
.unwrap()
.to_owned();
let wrong_sig = "1".repeat(leaked_signature_would_be.len());
body.as_object_mut().unwrap().insert(
"hmac_signature".into(),
serde_json::Value::String(wrong_sig.clone()),
);
let data = serde_json::to_vec(&body).unwrap();
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler = |_value: serde_json::Value| async {};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
let captured = THREAD_EVENTS.with(|events| events.borrow().clone());
assert!(
!captured.is_empty(),
"a security event must be emitted on verification failure"
);
for event in captured.iter() {
assert!(
!event.contains(&wrong_sig) && !event.contains(&leaked_signature_would_be),
"security event log line must never contain the received or expected HMAC \
value (CONTRACT.md §8.4): {event}"
);
}
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
}
fn authz_canonical(key_version: u8, nonce: &str, issued_at: DateTime<Utc>) -> String {
format!(
concat!(
"{{",
"\"correlation_id\":\"11111111-1111-1111-1111-111111111111\",",
"\"tenant_id\":\"22222222-2222-2222-2222-222222222222\",",
"\"subject_id\":\"33333333-3333-3333-3333-333333333333\",",
"\"action\":\"read\",",
"\"resource_id\":\"44444444-4444-4444-4444-444444444444\",",
"\"scope\":\"sub\",",
"\"key_version\":{},",
"\"nonce\":\"{}\",",
"\"issued_at\":\"{}\"",
"}}"
),
key_version,
nonce,
issued_at.to_rfc3339(),
)
}
fn wire_bytes_with_signature(canonical: &str, sig: &str) -> Vec<u8> {
let without_close = &canonical[..canonical.len() - 1];
format!("{without_close},\"hmac_signature\":\"{sig}\"}}").into_bytes()
}
#[tokio::test]
async fn server_declaration_order_message_is_accepted() {
let key = b"declaration-order-signing-key";
let canonical = authz_canonical(2, "77777777-7777-7777-7777-777777777777", Utc::now());
let sig = sign_payload(key, canonical.as_bytes());
let data = wire_bytes_with_signature(&canonical, &sig);
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
1,
"a genuine server message signed in declaration order must verify \
and reach the handler (SDK-Q01)"
);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn server_declaration_order_message_tampered_is_rejected() {
let key = b"declaration-order-signing-key";
let canonical = authz_canonical(2, "88888888-8888-8888-8888-888888888888", Utc::now());
let sig = sign_payload(key, canonical.as_bytes());
let tampered_canonical = canonical.replace("\"read\"", "\"write\"");
let data = wire_bytes_with_signature(&tampered_canonical, &sig);
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
0,
"a tampered body must never reach the handler"
);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn hmac_signature_not_last_field_still_verifies() {
let key = b"declaration-order-signing-key";
let canonical = authz_canonical(2, "99999999-9999-9999-9999-999999999999", Utc::now());
let sig = sign_payload(key, canonical.as_bytes());
let canonical_inner = &canonical[1..]; let data = format!("{{\"hmac_signature\":\"{sig}\",{canonical_inner}").into_bytes();
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
1,
"shift_remove must preserve field order regardless of where \
hmac_signature sits, so the message still verifies"
);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn key_version_below_minimum_is_rejected_even_with_valid_signature() {
let key = b"declaration-order-signing-key";
let canonical = authz_canonical(1, "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", Utc::now());
let sig = sign_payload(key, canonical.as_bytes());
let data = wire_bytes_with_signature(&canonical, &sig);
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
0,
"key_version < 2 must be rejected even when the signature verifies (NEW-4 hard cutover)"
);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_true.load(Ordering::SeqCst), 0);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn stale_issued_at_is_rejected_even_with_valid_signature() {
let key = b"declaration-order-signing-key";
let stale = Utc::now() - chrono::Duration::minutes(10);
let canonical = authz_canonical(2, "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", stale);
let sig = sign_payload(key, canonical.as_bytes());
let data = wire_bytes_with_signature(&canonical, &sig);
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
0,
"a stale issued_at (outside the freshness skew) must be rejected"
);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 1);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn replayed_nonce_is_rejected_on_second_delivery() {
let key = b"declaration-order-signing-key";
let nonce = "cccccccc-cccc-cccc-cccc-cccccccccccc";
let canonical = authz_canonical(2, nonce, Utc::now());
let sig = sign_payload(key, canonical.as_bytes());
let replay = ReplayGuard::with_default_skew();
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
let first_delivery = RecordingDelivery::new(wire_bytes_with_signature(&canonical, &sig));
verify_and_dispatch(&first_delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
1,
"the first delivery of a fresh nonce must be accepted"
);
assert_eq!(first_delivery.acked.load(Ordering::SeqCst), 1);
let second_delivery = RecordingDelivery::new(wire_bytes_with_signature(&canonical, &sig));
verify_and_dispatch(&second_delivery, key, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
1,
"a replayed nonce must not reach the handler a second time"
);
assert_eq!(
second_delivery.nacked_requeue_false.load(Ordering::SeqCst),
1
);
assert_eq!(second_delivery.acked.load(Ordering::SeqCst), 0);
}
const REFERENCE_VECTORS_JSON: &str = include_str!("../../testdata/v2_reference_vectors.json");
fn hex_decode(s: &str) -> Vec<u8> {
hex::decode(s).expect("fixture hex field must decode")
}
#[test]
fn fixture_v2_reference_vectors_hmac_byte_parity() {
let fixture: serde_json::Value =
serde_json::from_str(REFERENCE_VECTORS_JSON).expect("fixture must parse as JSON");
let subkey = hex_decode(
fixture["hkdf"]["derived_subkey_hex"]
.as_str()
.expect("hkdf.derived_subkey_hex present"),
);
for message_type in ["authz_request", "audit_event"] {
let vector = &fixture[message_type];
let canonical = vector["canonical_signed_json"]
.as_str()
.unwrap_or_else(|| panic!("{message_type}.canonical_signed_json present"));
let expected_hmac = vector["hmac_signature_hex"]
.as_str()
.unwrap_or_else(|| panic!("{message_type}.hmac_signature_hex present"));
let sig = sign_payload(&subkey, canonical.as_bytes());
assert_eq!(
sig, expected_hmac,
"{message_type}: SDK sign_payload output must be byte-for-byte identical to \
the server-generated reference vector"
);
assert!(
verify_payload(&subkey, canonical.as_bytes(), expected_hmac),
"{message_type}: the server-generated signature must verify against the same \
derived subkey + canonical bytes"
);
}
}
#[tokio::test]
async fn fixture_v2_reference_vector_authz_request_accepted_by_consumer() {
let fixture: serde_json::Value =
serde_json::from_str(REFERENCE_VECTORS_JSON).expect("fixture must parse as JSON");
let vector = &fixture["authz_request"];
let canonical = vector["canonical_signed_json"]
.as_str()
.expect("authz_request.canonical_signed_json present");
let expected_hmac = vector["hmac_signature_hex"]
.as_str()
.expect("authz_request.hmac_signature_hex present");
let subkey = hex_decode(
fixture["hkdf"]["derived_subkey_hex"]
.as_str()
.expect("hkdf.derived_subkey_hex present"),
);
let data = wire_bytes_with_signature(canonical, expected_hmac);
let delivery = RecordingDelivery::new(data);
let replay = ReplayGuard::new(chrono::Duration::days(3650));
let handler_calls = Arc::new(AtomicUsize::new(0));
let handler_calls_clone = Arc::clone(&handler_calls);
let handler = move |_value: serde_json::Value| {
let calls = Arc::clone(&handler_calls_clone);
async move {
calls.fetch_add(1, Ordering::SeqCst);
}
};
verify_and_dispatch(&delivery, &subkey, &handler, &replay).await;
assert_eq!(
handler_calls.load(Ordering::SeqCst),
1,
"a genuine server-signed v2 reference vector must be accepted end-to-end"
);
assert_eq!(delivery.acked.load(Ordering::SeqCst), 1);
assert_eq!(delivery.nacked_requeue_false.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn consume_rejects_plaintext_amqp_url_against_a_routable_host() {
let err = consume(
"amqp://rabbitmq.example.com:5672",
"test-queue",
Sensitive::new(b"irrelevant-signing-key".to_vec()),
None,
|_value: serde_json::Value| async {},
)
.await
.expect_err(
"plaintext amqp:// against a routable host must be rejected before connecting (X-2)",
);
match err {
AxiamError::Network { message, .. } => {
assert!(message.contains("amqps"), "message: {message}");
}
other => panic!("expected Network error, got {other:?}"),
}
}
#[tokio::test]
async fn consume_rejects_plaintext_amqp_url_on_loopback_too() {
for url in [
"amqp://localhost:5672",
"amqp://127.0.0.1:5672",
"amqp://[::1]:5672",
] {
let err = consume(
url,
"test-queue",
Sensitive::new(b"irrelevant-signing-key".to_vec()),
None,
|_value: serde_json::Value| async {},
)
.await
.expect_err("plaintext is refused on loopback too (§8b rules 1 and 5)");
match err {
AxiamError::Network { message, .. } => assert!(
message.contains("amqps://"),
"the error must name the scheme to use, got: {message}"
),
other => panic!("expected Network error, got {other:?}"),
}
}
}
#[tokio::test]
async fn consume_rejects_an_unparseable_url_rather_than_dialling_it() {
for url in ["", "not a url at all", "://broker"] {
let err = consume(
url,
"test-queue",
Sensitive::new(b"irrelevant-signing-key".to_vec()),
None,
|_value: serde_json::Value| async {},
)
.await
.expect_err("an unparseable url must fail closed");
assert!(
matches!(err, AxiamError::Network { .. }),
"got {err:?} for {url:?}"
);
}
}
#[test]
fn extract_replay_fields_none_when_key_version_missing() {
let body = serde_json::json!({
"nonce": "some-nonce",
"issued_at": Utc::now().to_rfc3339(),
});
assert!(extract_replay_fields(&body).is_none());
}
#[test]
fn extract_replay_fields_none_when_issued_at_is_not_rfc3339() {
let body = serde_json::json!({
"key_version": 2,
"nonce": "some-nonce",
"issued_at": "not-a-timestamp",
});
assert!(extract_replay_fields(&body).is_none());
}
#[test]
fn validate_v2_replay_protection_rejects_missing_replay_fields() {
let body = serde_json::json!({ "action": "read" });
let replay = ReplayGuard::with_default_skew();
let result = validate_v2_replay_protection(&body, &replay);
assert!(result.is_err());
assert!(result.unwrap_err().contains("missing or malformed"));
}
#[test]
fn replay_guard_ttl_does_not_panic_on_an_extreme_skew() {
let guard = ReplayGuard::new(chrono::Duration::MAX);
let ttl = guard.ttl();
assert!(ttl.as_secs() > 0);
}
}