lib-q-romulus 0.0.2

Romulus-N and Romulus-M AEAD (SKINNY-128-384+), no_std / wasm-friendly
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

//! `lib_q_core::Aead` validation branches for [`RomulusNAead`] / [`RomulusMAead`] (sizes, truncated CT).

#![cfg(feature = "alloc")]

use lib_q_core::{
    Aead,
    AeadDecryptSemantic,
    AeadKey,
    DecryptSemanticOutcome,
    Error,
    Nonce,
};
use lib_q_romulus::{
    RomulusMAead,
    RomulusNAead,
};

#[test]
fn romulus_n_aead_invalid_key_size() {
    let aead = RomulusNAead::new();
    let key = AeadKey::new(vec![0u8; 15]);
    let nonce = Nonce::new(vec![0u8; 16]);
    let r = aead.encrypt(&key, &nonce, b"x", None);
    assert!(matches!(r, Err(Error::InvalidKeySize { .. })));
}

#[test]
fn romulus_n_aead_invalid_nonce_size() {
    let aead = RomulusNAead::new();
    let key = AeadKey::new(vec![0u8; 16]);
    let nonce = Nonce::new(vec![0u8; 15]);
    let r = aead.encrypt(&key, &nonce, b"x", None);
    assert!(matches!(r, Err(Error::InvalidNonceSize { .. })));
}

#[test]
fn romulus_n_aead_ciphertext_shorter_than_tag() {
    let aead = RomulusNAead::new();
    let key = AeadKey::new(vec![1u8; 16]);
    let nonce = Nonce::new(vec![2u8; 16]);
    let r = aead.decrypt(&key, &nonce, b"short", None);
    assert!(matches!(r, Err(Error::InvalidCiphertextSize { .. })));
}

#[test]
fn romulus_m_aead_invalid_key_size() {
    let aead = RomulusMAead::new();
    let key = AeadKey::new(vec![0u8; 17]);
    let nonce = Nonce::new(vec![0u8; 16]);
    let r = aead.encrypt(&key, &nonce, b"y", None);
    assert!(matches!(r, Err(Error::InvalidKeySize { .. })));
}

#[test]
fn romulus_m_aead_invalid_nonce_size() {
    let aead = RomulusMAead::new();
    let key = AeadKey::new(vec![0u8; 16]);
    let nonce = Nonce::new(vec![0u8; 17]);
    let r = aead.encrypt(&key, &nonce, b"y", None);
    assert!(matches!(r, Err(Error::InvalidNonceSize { .. })));
}

#[test]
fn romulus_m_aead_ciphertext_shorter_than_tag() {
    let aead = RomulusMAead::new();
    let key = AeadKey::new(vec![3u8; 16]);
    let nonce = Nonce::new(vec![4u8; 16]);
    let r = aead.decrypt(&key, &nonce, &[0u8; 8], None);
    assert!(matches!(r, Err(Error::InvalidCiphertextSize { .. })));
}

#[test]
fn romulus_facade_size_constants() {
    assert_eq!(RomulusNAead::key_size(), 16);
    assert_eq!(RomulusNAead::nonce_size(), 16);
    assert_eq!(RomulusNAead::tag_size(), 16);
    assert_eq!(RomulusMAead::key_size(), 16);
    assert_eq!(RomulusMAead::nonce_size(), 16);
    assert_eq!(RomulusMAead::tag_size(), 16);
}

#[test]
fn romulus_n_decrypt_semantic_tampered_tag() {
    let aead = RomulusNAead::new();
    let key = AeadKey::new(vec![0x11u8; 16]);
    let nonce = Nonce::new(vec![0x22u8; 16]);
    let pt = b"romulus-n-msg";
    let mut ct = aead.encrypt(&key, &nonce, pt, None).expect("encrypt");
    let last = ct.len() - 1;
    ct[last] ^= 1;
    let out = aead
        .decrypt_semantic(&key, &nonce, &ct, None)
        .expect("semantic decrypt operational");
    assert_eq!(out, DecryptSemanticOutcome::AuthenticationFailed);
}

#[test]
fn romulus_n_decrypt_semantic_success_matches_layer_a() {
    let aead = RomulusNAead::new();
    let key = AeadKey::new(vec![0x33u8; 16]);
    let nonce = Nonce::new(vec![0x44u8; 16]);
    let ad = b"ad";
    let pt = b"body";
    let ct = aead.encrypt(&key, &nonce, pt, Some(ad)).expect("encrypt");
    let layer_a = aead.decrypt(&key, &nonce, &ct, Some(ad)).expect("decrypt");
    match aead
        .decrypt_semantic(&key, &nonce, &ct, Some(ad))
        .expect("decrypt_semantic")
    {
        DecryptSemanticOutcome::Success(got) => assert_eq!(got.as_slice(), layer_a.as_slice()),
        DecryptSemanticOutcome::AuthenticationFailed => panic!("expected Success"),
    }
}

#[test]
fn romulus_m_decrypt_semantic_tampered_tag() {
    let aead = RomulusMAead::new();
    let key = AeadKey::new(vec![0x55u8; 16]);
    let nonce = Nonce::new(vec![0x66u8; 16]);
    let pt = b"romulus-m-msg";
    let mut ct = aead.encrypt(&key, &nonce, pt, None).expect("encrypt");
    let last = ct.len() - 1;
    ct[last] ^= 1;
    let out = aead
        .decrypt_semantic(&key, &nonce, &ct, None)
        .expect("semantic decrypt operational");
    assert_eq!(out, DecryptSemanticOutcome::AuthenticationFailed);
}