Merge pull request #41 from Foundation-Devices/prevent-replay-attacks

SFT-5885: Prevent replay attacks

Author: icota

Cargo.lock

@@ -33,6 +33,8 @@ flutter_rust_bridge = "=2.11.1"
 quantum-link-macros = { workspace = true }
 gstp = "0.5.0"
 bc-components = "0.17.0"
+dcbor = "0.16.5"
+chrono = "0.4"
 
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(frb_expand)'] }

api/Cargo.toml

@@ -1,16 +1,71 @@
+use std::time::Duration;
+
 use anyhow::bail;
 use bc_components::{EncapsulationScheme, PrivateKeys, PublicKeys, SignatureScheme, ARID};
 use bc_envelope::{
     prelude::{CBORCase, CBOR},
     Envelope, EventBehavior, Expression, ExpressionBehavior, Function,
 };
 use bc_xid::XIDDocument;
+use chrono::{DateTime, Utc};
+use dcbor::Date;
 use flutter_rust_bridge::frb;
 use gstp::{SealedEvent, SealedEventBehavior};
 
 use crate::message::{EnvoyMessage, PassportMessage};
 
 pub const QUANTUM_LINK: Function = Function::new_static_named("quantumLink");
+pub const EXPIRATION_DURATION: Duration = Duration::from_secs(60);
+
+/// Storage for tracking received ARIDs to prevent replay attacks
+#[derive(Debug, Default, Clone)]
+pub struct ARIDCache {
+    cache: Vec<(ARID, DateTime<Utc>)>,
+}
+
+impl ARIDCache {
+    pub fn new() -> Self {
+        Self { cache: Vec::new() }
+    }
+
+    /// Check if ARID has been seen before and store it if not
+    /// Returns true if this is a replay attack (ARID already exists)
+    pub fn check_and_store(
+        &mut self,
+        arid: &ARID,
+        sent_at: DateTime<Utc>,
+        now: DateTime<Utc>,
+    ) -> bool {
+        // Clean up expired entries first
+        self.cache
+            .retain(|(_, date)| now < (*date + EXPIRATION_DURATION));
+
+        // Check if ARID already exists (replay attack)
+        if self.cache.iter().any(|(id, _)| id == arid) {
+            return true; // Replay attack detected
+        }
+
+        if now < (sent_at + EXPIRATION_DURATION) {
+            self.cache.push((arid.clone(), sent_at));
+        }
+        false // Not a replay attack
+    }
+
+    /// Get the number of stored ARIDs
+    pub fn len(&self) -> usize {
+        self.cache.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.cache.len() == 0
+    }
+
+    /// Clear all stored ARIDs
+    pub fn clear(&mut self) {
+        self.cache.clear();
+    }
+}
+
 pub trait QuantumLink<C>: minicbor::Encode<C> {
     fn encode(&self) -> Expression
     where
@@ -46,11 +101,14 @@ pub trait QuantumLink<C>: minicbor::Encode<C> {
     where
         Self: minicbor::Encode<()>,
     {
+        let valid_until = Date::with_duration_from_now(EXPIRATION_DURATION);
+
         let event: SealedEvent<Expression> =
-            SealedEvent::new(QuantumLink::encode(self), ARID::new(), sender.xid_document);
+            SealedEvent::new(QuantumLink::encode(self), ARID::new(), sender.xid_document)
+                .with_date(&valid_until);
         event
             .to_envelope(
-                None,
+                Some(&valid_until),
                 Some(&sender.private_keys.unwrap()),
                 Some(&recipient.xid_document),
             )
@@ -65,7 +123,30 @@ pub trait QuantumLink<C>: minicbor::Encode<C> {
         Self: for<'a> minicbor::Decode<'a, ()>,
     {
         let event: SealedEvent<Expression> =
-            SealedEvent::try_from_envelope(envelope, None, None, private_keys)?;
+            SealedEvent::try_from_envelope(envelope, None, Some(&Date::now()), private_keys)?;
+        let expression = event.content().clone();
+        Ok((expression, event.sender().clone()))
+    }
+
+    fn unseal_with_replay_check(
+        envelope: &Envelope,
+        private_keys: &PrivateKeys,
+        arid_cache: &mut ARIDCache,
+    ) -> anyhow::Result<(Expression, XIDDocument)>
+    where
+        Self: for<'a> minicbor::Decode<'a, ()>,
+    {
+        let now = Utc::now();
+        let event: SealedEvent<Expression> =
+            SealedEvent::try_from_envelope(envelope, None, Some(&Date::from(now)), private_keys)?;
+
+        // Check for replay attack
+        let arid = event.id();
+        let event_date = event.date().unwrap().datetime();
+        if arid_cache.check_and_store(arid, event_date, now) {
+            bail!("Replay attack detected: ARID has been seen before");
+        }
+
         let expression = event.content().clone();
         Ok((expression, event.sender().clone()))
     }
@@ -78,13 +159,33 @@ pub trait QuantumLink<C>: minicbor::Encode<C> {
         Ok((PassportMessage::decode(&expression)?, sender))
     }
 
+    fn unseal_passport_message_with_replay_check(
+        envelope: &Envelope,
+        private_keys: &PrivateKeys,
+        arid_cache: &mut ARIDCache,
+    ) -> anyhow::Result<(PassportMessage, XIDDocument)> {
+        let (expression, sender) =
+            PassportMessage::unseal_with_replay_check(envelope, private_keys, arid_cache)?;
+        Ok((PassportMessage::decode(&expression)?, sender))
+    }
+
     fn unseal_envoy_message(
         envelope: &Envelope,
         private_keys: &PrivateKeys,
     ) -> anyhow::Result<(EnvoyMessage, XIDDocument)> {
         let (expression, sender) = EnvoyMessage::unseal(envelope, private_keys)?;
         Ok((EnvoyMessage::decode(&expression)?, sender))
     }
+
+    fn unseal_envoy_message_with_replay_check(
+        envelope: &Envelope,
+        private_keys: &PrivateKeys,
+        arid_cache: &mut ARIDCache,
+    ) -> anyhow::Result<(EnvoyMessage, XIDDocument)> {
+        let (expression, sender) =
+            EnvoyMessage::unseal_with_replay_check(envelope, private_keys, arid_cache)?;
+        Ok((EnvoyMessage::decode(&expression)?, sender))
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -149,7 +250,7 @@ mod tests {
         api::{message::QuantumLinkMessage, quantum_link::QuantumLink},
         fx::ExchangeRate,
         message::EnvoyMessage,
-        quantum_link::QuantumLinkIdentity,
+        quantum_link::{ARIDCache, QuantumLinkIdentity},
     };
 
     #[test]
@@ -212,4 +313,133 @@ mod tests {
             deserialized_identity.private_keys.unwrap()
         );
     }
+
+    #[test]
+    fn test_replay_attack_prevention() {
+        let envoy = QuantumLinkIdentity::generate();
+        let passport = QuantumLinkIdentity::generate();
+        let mut arid_cache = ARIDCache::new();
+
+        let fx_rate = ExchangeRate::new("USD", 0.85);
+        let original_message = EnvoyMessage {
+            message: QuantumLinkMessage::ExchangeRate(fx_rate.clone()),
+            timestamp: 123456,
+        };
+
+        // Seal the message
+        let envelope = QuantumLink::seal(&original_message, envoy.clone(), passport.clone());
+
+        // First unseal should succeed
+        let result1 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+            &envelope,
+            &passport.private_keys.clone().unwrap(),
+            &mut arid_cache,
+        );
+        assert!(result1.is_ok());
+
+        // Second unseal of the same message should fail (replay attack)
+        let result2 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+            &envelope,
+            &passport.private_keys.unwrap(),
+            &mut arid_cache,
+        );
+        assert!(result2.is_err());
+        assert!(result2
+            .unwrap_err()
+            .to_string()
+            .contains("Replay attack detected"));
+    }
+
+    #[test]
+    fn test_arid_cache_cleanup() {
+        let mut arid_cache = ARIDCache::new();
+        let envoy = QuantumLinkIdentity::generate();
+        let passport = QuantumLinkIdentity::generate();
+
+        // Create and seal multiple messages
+        let fx_rate = ExchangeRate::new("USD", 0.85);
+        let message1 = EnvoyMessage {
+            message: QuantumLinkMessage::ExchangeRate(fx_rate.clone()),
+            timestamp: 123456,
+        };
+        let message2 = EnvoyMessage {
+            message: QuantumLinkMessage::ExchangeRate(fx_rate.clone()),
+            timestamp: 123457,
+        };
+
+        let envelope1 = QuantumLink::seal(&message1, envoy.clone(), passport.clone());
+        let envelope2 = QuantumLink::seal(&message2, envoy.clone(), passport.clone());
+
+        // Unseal both messages
+        let _result1 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+            &envelope1,
+            &passport.private_keys.clone().unwrap(),
+            &mut arid_cache,
+        )
+        .unwrap();
+        let _result2 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+            &envelope2,
+            &passport.private_keys.unwrap(),
+            &mut arid_cache,
+        )
+        .unwrap();
+
+        // Should have 2 ARIDs stored
+        assert_eq!(arid_cache.len(), 2);
+
+        // Clear cache manually to test cleanup
+        arid_cache.clear();
+        assert_eq!(arid_cache.len(), 0);
+    }
+}
+
+#[test]
+fn test_time_based_eviction() {
+    let mut cache = ARIDCache::new();
+    let arid1 = ARID::new();
+    let arid2 = ARID::new();
+
+    let expiration = chrono::Duration::from_std(EXPIRATION_DURATION).unwrap();
+    let start = chrono::Utc::now();
+
+    cache.check_and_store(&arid1, start, start);
+    assert_eq!(cache.len(), 1);
+
+    // evict the old time
+    // evict the old time by advancing 'now' past expiration
+    let future = start + expiration + chrono::Duration::seconds(1);
+    cache.check_and_store(&arid2, future, future);
+    assert_eq!(cache.len(), 1);
+    assert!(!cache.cache.iter().any(|(id, _)| id == &arid1));
+}
+
+#[test]
+fn test_replay_check() {
+    use crate::{fx::ExchangeRate, message::QuantumLinkMessage};
+
+    let mut arid_cache = ARIDCache::new();
+    let envoy = QuantumLinkIdentity::generate();
+    let passport = QuantumLinkIdentity::generate();
+
+    let fx_rate = ExchangeRate::new("USD", 0.85);
+    let message = EnvoyMessage {
+        message: QuantumLinkMessage::ExchangeRate(fx_rate),
+        timestamp: 123456,
+    };
+
+    let envelope = QuantumLink::seal(&message, envoy.clone(), passport.clone());
+
+    let result1 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+        &envelope,
+        &passport.private_keys.clone().unwrap(),
+        &mut arid_cache,
+    );
+    assert!(result1.is_ok());
+
+    let result2 = EnvoyMessage::unseal_envoy_message_with_replay_check(
+        &envelope,
+        &passport.private_keys.unwrap(),
+        &mut arid_cache,
+    );
+    assert!(result2.is_err());
 }

api/src/api/quantum_link.rs

@@ -31,7 +31,11 @@
         };
       in {
         default = pkgs.mkShellNoCC {
-          packages = [toolchain];
+          packages = with pkgs;
+            [gcc]
+            ++ [
+              toolchain
+            ];
         };
       }
     );

flake.nix

@@ -3,3 +3,4 @@
 
 [toolchain]
 channel = "nightly-2025-06-24"
+components = ["rust-analyzer", "rust-src"]