use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::error::AxiamError;
const RESERVED_AUDIT_PREFIXES: [&str; 2] = ["tenants.", "gdpr."];
fn is_reserved_audit_action(action: &str) -> bool {
RESERVED_AUDIT_PREFIXES.iter().any(|prefix| {
action
.as_bytes()
.get(..prefix.len())
.is_some_and(|head| head.eq_ignore_ascii_case(prefix.as_bytes()))
})
}
#[derive(Debug, Deserialize, Serialize)]
pub struct AuthzRequest {
pub correlation_id: Uuid,
pub tenant_id: Uuid,
pub subject_id: Uuid,
pub action: String,
pub resource_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
pub key_version: u8,
pub nonce: Uuid,
pub issued_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hmac_signature: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct AuditEventMessage {
pub tenant_id: Uuid,
pub actor_id: Uuid,
pub actor_type: String,
pub action: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
pub outcome: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
pub key_version: u8,
pub nonce: Uuid,
pub issued_at: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hmac_signature: Option<String>,
}
impl AuditEventMessage {
pub fn check_action(&self) -> Result<(), AxiamError> {
if !is_reserved_audit_action(&self.action) {
return Ok(());
}
Err(crate::management::error::local_refusal(
"audit.publish",
"action",
"the `tenants.` and `gdpr.` namespaces are reserved for the server's own audit \
records and are refused by the audit ingestion (CONTRACT.md §8)",
))
}
pub fn sign(&mut self, signing_key: &[u8]) -> Result<(), AxiamError> {
self.check_action()?;
self.hmac_signature = None;
let bytes = serde_json::to_vec(&*self)
.map_err(|e| AxiamError::network(format!("audit event serialization failed: {e}")))?;
self.hmac_signature = Some(crate::amqp::hmac::sign_payload(signing_key, &bytes));
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn message(action: &str) -> AuditEventMessage {
AuditEventMessage {
tenant_id: Uuid::nil(),
actor_id: Uuid::nil(),
actor_type: "user".into(),
action: action.into(),
resource_id: None,
outcome: "success".into(),
ip_address: None,
metadata: None,
key_version: 2,
nonce: Uuid::nil(),
issued_at: Utc::now(),
hmac_signature: None,
}
}
#[test]
fn reserved_actions_are_refused_ascii_case_insensitively() {
for action in [
"tenants.delete",
"Tenants.audit_exported",
"GDPR.erase",
"gdpr.x",
] {
let mut m = message(action);
assert!(m.check_action().is_err(), "{action}");
assert!(
m.sign(Uuid::new_v4().as_bytes()).is_err(),
"{action} must not be signed"
);
assert!(m.hmac_signature.is_none(), "{action}: nothing signed");
}
}
#[test]
fn refusal_names_the_namespace_and_not_the_action() {
let e = message("tenants.secret_action").check_action().unwrap_err();
let text = e.to_string();
assert!(text.contains("tenants."), "{text}");
assert!(!text.contains("secret_action"), "{text}");
}
#[test]
fn other_actions_pass_and_sign() {
for action in [
"login",
"role.assign",
"tenant.x",
"gdprx",
"tenants",
"éenants.x",
] {
let mut m = message(action);
m.sign(Uuid::new_v4().as_bytes())
.unwrap_or_else(|e| panic!("{action}: {e}"));
assert!(m.hmac_signature.is_some());
}
}
}