Skip to main content

protocol_7h3/
queue.rs

1//! Queue binding — signed message envelope for Kafka/SQS/Pub-Sub transit.
2
3use crate::{
4    create_envelope, sign_envelope_ed25519, validate_envelope, verify_envelope_ed25519,
5    ProtocolBody, ProtocolEnvelope,
6};
7use serde::{Deserialize, Serialize};
8
9pub const DEFAULT_TTL_MS: i64 = 3_600_000;
10
11#[derive(Serialize, Deserialize)]
12pub struct QueueMessage<T: Serialize> {
13    pub envelope: ProtocolEnvelope,
14    pub payload: T,
15}
16
17fn now_ms() -> i64 {
18    std::time::SystemTime::now()
19        .duration_since(std::time::UNIX_EPOCH)
20        .unwrap_or_default()
21        .as_millis() as i64
22}
23
24/// Sign a payload for queue transit. Returns a JSON string.
25pub fn sign_queue_message<T: Serialize>(
26    payload: &T,
27    private_key: &str,
28    key_id: &str,
29    sender: &str,
30    recipient: Option<&str>,
31    ttl_ms: Option<i64>,
32) -> Result<String, Box<dyn std::error::Error>> {
33    let content = serde_json::to_string(payload)?;
34    let now = now_ms();
35    let envelope = create_envelope(
36        sender,
37        recipient,
38        "TASK",
39        &content,
40        None,
41        None,
42        now,
43        ttl_ms.unwrap_or(DEFAULT_TTL_MS),
44    );
45    let signed = sign_envelope_ed25519(&envelope, private_key, key_id)
46        .map_err(|e| -> Box<dyn std::error::Error> { e.into() })?;
47    // Re-serialize payload as Value so the QueueMessage wrapper holds both fields
48    let payload_value = serde_json::to_value(payload)?;
49    let msg = serde_json::json!({
50        "envelope": signed,
51        "payload": payload_value,
52    });
53    Ok(serde_json::to_string(&msg)?)
54}
55
56/// Verify and unwrap a queue message. Returns (payload_json_value, envelope).
57pub fn verify_queue_message(
58    message: &str,
59    public_key: &str,
60) -> Result<(serde_json::Value, ProtocolEnvelope), Box<dyn std::error::Error>> {
61    let wrapper: serde_json::Value = serde_json::from_str(message)?;
62
63    let envelope: ProtocolEnvelope = serde_json::from_value(wrapper["envelope"].clone())
64        .map_err(|e| -> Box<dyn std::error::Error> { format!("malformed envelope: {e}").into() })?;
65
66    let now = now_ms();
67    let diags = validate_envelope(&envelope, Some(now));
68    if diags.iter().any(|d| d.level == "error") {
69        return Err("envelope expired or invalid".into());
70    }
71
72    let valid = verify_envelope_ed25519(&envelope, public_key)
73        .map_err(|e| -> Box<dyn std::error::Error> { e.into() })?;
74    if !valid {
75        return Err("invalid signature".into());
76    }
77
78    // The signature covers envelope.body.content, NOT the sibling "payload"
79    // field. Returning it unchecked meant an attacker could take any validly
80    // signed message, swap the payload for anything, and the signature would
81    // still verify while the consumer acted on attacker-controlled data — a
82    // complete integrity bypass on a transport whose whole purpose is integrity.
83    // Serialized exactly as sign_queue_message does, so honest messages match.
84    let payload = wrapper["payload"].clone();
85    let presented = serde_json::to_string(&payload)
86        .map_err(|e| -> Box<dyn std::error::Error> { format!("malformed payload: {e}").into() })?;
87    if presented != envelope.body.content {
88        return Err(
89            "queue message payload does not match the signed content — the payload field was modified in transit"
90                .into(),
91        );
92    }
93
94    Ok((payload, envelope))
95}