revery 0.1.0

💭 Conversations that never happened.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Secure messaging - Encrypted conversations with deniability

mod conversation;
mod error;
pub mod message;

pub use conversation::Conversation;
pub use error::SessionError;
pub use message::{ContentType, Message};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_message_encrypt_decrypt() {
        let encryption_key = [0x42; 32];
        let signing_key = [0x43; 32];
        let sequence = 1;
        let timestamp = 1698123456;
        let plaintext = b"Hello, world!";

        let message = Message::encrypt(
            sequence,
            timestamp,
            ContentType::Text,
            plaintext,
            &encryption_key,
            &signing_key,
        );

        assert_eq!(message.sequence, sequence);
        assert_eq!(message.timestamp, timestamp);
        assert_eq!(message.content_type, ContentType::Text as u8);
        assert_ne!(message.payload, plaintext);

        let decrypted = message.decrypt(&encryption_key, &signing_key).unwrap();
        assert_eq!(decrypted, plaintext);
    }

    #[test]
    fn test_message_forgery() {
        let encryption_key = [0x42; 32];
        let signing_key = [0x43; 32];
        let sequence = 5;
        let timestamp = 1698123500;

        let original_text = b"I agree to the terms";
        let original_message = Message::encrypt(
            sequence,
            timestamp,
            ContentType::Text,
            original_text,
            &encryption_key,
            &signing_key,
        );

        let forged_text = b"I disagree completely";
        let forged_message = Message::encrypt(
            sequence,
            timestamp,
            ContentType::Text,
            forged_text,
            &encryption_key,
            &signing_key,
        );

        assert_eq!(original_message.sequence, forged_message.sequence);
        assert_eq!(original_message.timestamp, forged_message.timestamp);
        assert_eq!(original_message.content_type, forged_message.content_type);

        assert_ne!(original_message.payload, forged_message.payload);

        let decrypted_original = original_message
            .decrypt(&encryption_key, &signing_key)
            .unwrap();
        let decrypted_forged = forged_message
            .decrypt(&encryption_key, &signing_key)
            .unwrap();

        assert_eq!(decrypted_original, original_text);
        assert_eq!(decrypted_forged, forged_text);
    }

    #[test]
    fn test_hmac_prevents_tampering() {
        let encryption_key = [0x42; 32];
        let signing_key = [0x43; 32];
        let sequence = 1;
        let timestamp = 1698123456;
        let plaintext = b"Original message";

        let mut message = Message::encrypt(
            sequence,
            timestamp,
            ContentType::Text,
            plaintext,
            &encryption_key,
            &signing_key,
        );

        if !message.payload.is_empty() {
            message.payload[0] ^= 0xFF;
        }

        let result = message.decrypt(&encryption_key, &signing_key);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), SessionError::HmacVerificationFailed);
    }

    #[test]
    fn test_hmac_prevents_metadata_tampering() {
        let encryption_key = [0x42; 32];
        let signing_key = [0x43; 32];
        let sequence = 1;
        let timestamp = 1698123456;
        let plaintext = b"Original message";

        let mut message = Message::encrypt(
            sequence,
            timestamp,
            ContentType::Text,
            plaintext,
            &encryption_key,
            &signing_key,
        );

        message.sequence = 999;

        let result = message.decrypt(&encryption_key, &signing_key);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), SessionError::HmacVerificationFailed);
    }

    #[test]
    fn test_conversation_created_at() {
        let shared_secret = b"test-shared-secret-data";
        let address = "test.onion";

        let before = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        let conversation = Conversation::new(shared_secret, address);

        let after = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        let created_at = conversation.created_at();

        // Verify the timestamp is reasonable (within a few seconds of creation)
        assert!(created_at >= before);
        assert!(created_at <= after);
    }
}