1use crate::{generate, lqb, util, ArxKW, ArxKwError, AuthTag, ConstantTimeEq, InvalidLengthError};
2
3pub struct G;
6impl G {
7 #[must_use]
9 pub const fn key_length() -> usize {
10 32
11 }
12
13 #[must_use]
21 pub const fn max_input_length() -> usize {
22 64
23 }
24}
25
26impl ArxKW for G {
27 type Key = [u8; Self::key_length()];
28 const VARIANT_ID: u8 = 2;
29 const MAX_INPUT_LENGTH: usize = 64;
30 fn encrypt(key: &Self::Key, plaintext: &[u8]) -> Result<(Vec<u8>, AuthTag), ArxKwError> {
31 if plaintext.len() > Self::max_input_length() {
32 Err(ArxKwError::InvalidLength(InvalidLengthError::UpTo(
33 plaintext.len(),
34 Self::max_input_length(),
35 )))
36 } else {
37 let (k1, k2) = generate::subkeys(key)?;
38 let authentication_tag = util::sip_array_keyed(&k1, plaintext);
39 let ciphertext = lqb::chacha8_encrypt(&k2, authentication_tag.as_ref(), plaintext)?;
40 Ok((ciphertext, authentication_tag))
41 }
42 }
43
44 fn decrypt(
45 key: &Self::Key,
46 ciphertext: &[u8],
47 authentication_tag: &AuthTag,
48 ) -> Result<Vec<u8>, ArxKwError> {
49 if ciphertext.len() > Self::max_input_length() {
50 Err(ArxKwError::InvalidLength(InvalidLengthError::UpTo(
51 ciphertext.len(),
52 Self::max_input_length(),
53 )))
54 } else {
55 let (k1, k2) = generate::subkeys(key)?;
56 let mut p_prime = zeroize::Zeroizing::new(lqb::chacha8_encrypt(
57 &k2,
58 authentication_tag.as_ref(),
59 ciphertext,
60 )?);
61 let t_prime = zeroize::Zeroizing::new(util::sip_array_keyed(&k1, &p_prime));
62 if bool::from(t_prime.ct_eq(authentication_tag)) {
63 return Ok(std::mem::take(&mut *p_prime));
64 }
65 Err(ArxKwError::BadTags)
66 }
67 }
68}
69
70#[cfg(test)]
71mod tests {
72 use super::{ArxKW, G};
73 use crate::{assert_ct_eq, AuthTag};
74 use anyhow::Result;
75 use hex::FromHex;
76
77 #[test]
78 fn test_encrypt() -> Result<()> {
79 let k = <[u8; 32]>::from_hex(
80 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
81 )?;
82 let p = <[u8; 32]>::from_hex(
83 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
84 )?;
85 let p_bad = [0xaf; 69];
86 let res = G::encrypt(&k, &p_bad);
87 assert!(res.is_err());
88 let t_expected = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
89 let c_expected = <[u8; 32]>::from_hex(
90 "f63830f5148a039b6aacc4b9b6bc281d7704d906e4b5d91e045a62cdfc25eb10",
91 )?;
92 let (c, t) = G::encrypt(&k, &p)?;
93 assert_ct_eq!(c, &c_expected);
94 assert_ct_eq!(t, &t_expected);
95 Ok(())
96 }
97
98 #[test]
99 fn test_encrypt_blob() -> Result<()> {
100 let k = <[u8; 32]>::from_hex(
101 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
102 )?;
103 let p = <[u8; 32]>::from_hex(
104 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
105 )?;
106 let blob_expected = <[u8;48]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65f63830f5148a039b6aacc4b9b6bc281d7704d906e4b5d91e045a62cdfc25eb10")?;
107 let blob = G::encrypt_blob(&k, &p)?;
108 assert_ct_eq!(blob_expected, &blob);
109 Ok(())
110 }
111
112 #[test]
113 fn test_decrypt_blob() -> Result<()> {
114 let k = <[u8; 32]>::from_hex(
115 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
116 )?;
117 let p_expected = <[u8; 32]>::from_hex(
118 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
119 )?;
120 let blob = <[u8;48]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65f63830f5148a039b6aacc4b9b6bc281d7704d906e4b5d91e045a62cdfc25eb10")?;
121 let p = G::decrypt_blob(&k, &blob)?;
122 assert_ct_eq!(p, &p_expected);
123 Ok(())
124 }
125
126 #[test]
127 fn test_decrypt() -> Result<()> {
128 let k = <[u8; 32]>::from_hex(
129 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
130 )?;
131 let p_expected = <[u8; 32]>::from_hex(
132 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
133 )?;
134 let p_bad = [0xaf; 69];
135 let t_expected = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
136 let res = G::decrypt(&k, &p_bad, &t_expected);
137 assert!(res.is_err());
138 let c = <[u8; 32]>::from_hex(
139 "f63830f5148a039b6aacc4b9b6bc281d7704d906e4b5d91e045a62cdfc25eb10",
140 )?;
141 let p = G::decrypt(&k, &c, &t_expected)?;
142 assert_eq!(p, p_expected);
143 Ok(())
144 }
145
146 #[test]
147 fn test_decrypt_bad() -> Result<()> {
148 let k = <[u8; 32]>::from_hex(
149 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
150 )?;
151 let p_expected = <[u8; 32]>::from_hex(
152 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
153 )?;
154 let c = <[u8; 32]>::from_hex(
155 "f63830f5148a039b6aacc4b9b6bc281d7704d906e4b5d91e045a62cdfc25eb10",
156 )?;
157 let c_bad = [0xaf; 69];
158 let t_expected = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
159 let res = G::decrypt(&k, &c_bad, &t_expected);
160 assert!(res.is_err());
161 let p = G::decrypt(&k, &c, &t_expected)?;
162 assert_eq!(p, p_expected);
163 let t_bad = AuthTag(<[u8; 16]>::from_hex("dab325cf6a3c4b2e3b039675e1ccbc65")?); let res = G::decrypt(&k, &c, &t_bad);
165 assert!(res.is_err());
166 Ok(())
167 }
168}