shadow_integration_tests/
crypto_messaging.rs

1//! Crypto → Messaging integration tests
2
3use shadow_core::PeerId;
4
5/// Test the full messaging pipeline: key exchange → encrypt → serialize → deserialize → decrypt
6pub fn test_full_messaging_pipeline() -> Result<(), String> {
7    let alice_sk = crypto::SigningKey::generate();
8    let alice_id = PeerId::random();
9    let bob_sk = crypto::SigningKey::generate();
10    let bob_id = PeerId::random();
11    let alice_vk = alice_sk.verify_key();
12    let bob_vk = bob_sk.verify_key();
13
14    // Key exchange
15    let (alice_state, alice_pub) = messaging::SecureChannel::initiate(alice_sk, alice_id);
16    let (bob_state, bob_pub) = messaging::SecureChannel::initiate(bob_sk, bob_id);
17
18    let alice_chan = messaging::SecureChannel::complete(alice_state, &bob_pub, bob_vk)
19        .map_err(|e| format!("Alice channel complete failed: {}", e))?;
20    let bob_chan = messaging::SecureChannel::complete(bob_state, &alice_pub, alice_vk)
21        .map_err(|e| format!("Bob channel complete failed: {}", e))?;
22
23    // Create a message
24    let original = messaging::Message::text(
25        alice_id,
26        messaging::MessageTarget::Direct(bob_id),
27        "Integration test: crypto→messaging pipeline",
28    );
29
30    // Encrypt message
31    let envelope = alice_chan
32        .encrypt_message(&original)
33        .map_err(|e| format!("Encrypt failed: {}", e))?;
34
35    // Serialize envelope for transport
36    let envelope_bytes = envelope
37        .to_bytes()
38        .map_err(|e| format!("Envelope serialize failed: {}", e))?;
39
40    // Deserialize envelope (simulating network receive)
41    let received_envelope = messaging::EncryptedEnvelope::from_bytes(&envelope_bytes)
42        .map_err(|e| format!("Envelope deserialize failed: {}", e))?;
43
44    // Decrypt
45    let received_msg = bob_chan
46        .decrypt_message(&received_envelope)
47        .map_err(|e| format!("Decrypt failed: {}", e))?;
48
49    // Verify sender
50    if received_msg.sender != alice_id {
51        return Err("Sender mismatch".into());
52    }
53
54    Ok(())
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60
61    #[test]
62    fn test_crypto_messaging_integration() {
63        test_full_messaging_pipeline().unwrap();
64    }
65
66    #[test]
67    fn test_multiple_messages() {
68        let alice_sk = crypto::SigningKey::generate();
69        let alice_id = PeerId::random();
70        let bob_sk = crypto::SigningKey::generate();
71        let bob_id = PeerId::random();
72        let alice_vk = alice_sk.verify_key();
73        let bob_vk = bob_sk.verify_key();
74
75        let (a_state, a_pub) = messaging::SecureChannel::initiate(alice_sk, alice_id);
76        let (b_state, b_pub) = messaging::SecureChannel::initiate(bob_sk, bob_id);
77        let a_chan = messaging::SecureChannel::complete(a_state, &b_pub, bob_vk).unwrap();
78        let b_chan = messaging::SecureChannel::complete(b_state, &a_pub, alice_vk).unwrap();
79
80        for i in 0..50 {
81            let msg = messaging::Message::text(
82                alice_id,
83                messaging::MessageTarget::Direct(bob_id),
84                format!("message #{}", i),
85            );
86            let enc = a_chan.encrypt_message(&msg).unwrap();
87            let dec = b_chan.decrypt_message(&enc).unwrap();
88            assert_eq!(dec.sender, alice_id);
89
90            let reply = messaging::Message::text(
91                bob_id,
92                messaging::MessageTarget::Direct(alice_id),
93                format!("reply #{}", i),
94            );
95            let enc2 = b_chan.encrypt_message(&reply).unwrap();
96            let dec2 = a_chan.decrypt_message(&enc2).unwrap();
97            assert_eq!(dec2.sender, bob_id);
98        }
99    }
100
101    #[test]
102    fn test_message_content_types() {
103        let sender = PeerId::random();
104        let target = messaging::MessageTarget::Direct(PeerId::random());
105
106        let msg_text = messaging::Message::new(
107            sender,
108            target.clone(),
109            messaging::MessageContent::Text("hello".into()),
110        );
111        let bytes = msg_text.to_bytes().unwrap();
112        let decoded = messaging::Message::from_bytes(&bytes).unwrap();
113        assert_eq!(decoded.sender, sender);
114
115        let msg_binary = messaging::Message::new(
116            sender,
117            target.clone(),
118            messaging::MessageContent::Binary(vec![1, 2, 3, 4, 5]),
119        );
120        let bytes2 = msg_binary.to_bytes().unwrap();
121        let decoded2 = messaging::Message::from_bytes(&bytes2).unwrap();
122        assert_eq!(decoded2.sender, sender);
123    }
124}
shadow_integration_tests/crypto_messaging.rs

shadow_integration_tests/
crypto_messaging.rs
