1use crate::ConstantTimeEq;
2use crate::{generate, util, ArxKW, ArxKwError, AuthTag};
3
4pub struct GX;
7impl GX {
8 #[must_use]
10 pub const fn key_length() -> usize {
11 32
12 }
13}
14
15impl ArxKW for GX {
16 type Key = [u8; Self::key_length()];
17 const VARIANT_ID: u8 = 4;
18 fn encrypt(key: &Self::Key, plaintext: &[u8]) -> Result<(Vec<u8>, AuthTag), ArxKwError> {
19 crate::memory::check_length(plaintext.len(), Self::MAX_INPUT_LENGTH)?;
20 let (k1, k2) = generate::subkeys(key)?;
21 let authentication_tag = util::sip_array_keyed(&k1, plaintext);
22 let nonce = construct_nonce(&authentication_tag);
23 let mut stream = util::xchacha8::new(&k2, &nonce);
24 let mut ciphertext = crate::memory::copy_secret(plaintext)?;
25 stream.xor_read(&mut ciphertext)?;
26 Ok((std::mem::take(&mut *ciphertext), authentication_tag))
27 }
28 fn decrypt(
29 key: &Self::Key,
30 ciphertext: &[u8],
31 authentication_tag: &AuthTag,
32 ) -> Result<Vec<u8>, ArxKwError> {
33 crate::memory::check_length(ciphertext.len(), Self::MAX_INPUT_LENGTH)?;
34 let (k1, k2) = generate::subkeys(key)?;
35 let nonce = construct_nonce(authentication_tag);
36 let mut stream = util::xchacha8::new(&k2, &nonce);
37 let mut p_prime = crate::memory::copy_secret(ciphertext)?;
38 stream.xor_read(&mut p_prime)?;
39 let t_prime = zeroize::Zeroizing::new(util::sip_array_keyed(&k1, &p_prime));
40 if bool::from(t_prime.ct_eq(authentication_tag)) {
41 return Ok(std::mem::take(&mut *p_prime));
43 }
44 Err(ArxKwError::BadTags)
45 }
46}
47const NONCE_INIT_GX: [u8; 24] = [
49 0x61, 0x72, 0x62, 0x69, 0x74, 0x72, 0x47, 0x58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
50];
51
52#[must_use]
90#[inline]
91pub fn construct_nonce(authentication_tag: &AuthTag) -> [u8; 24] {
92 let mut nonce = NONCE_INIT_GX;
94 nonce[8..24].clone_from_slice(authentication_tag.as_ref());
96 nonce
97}
98
99#[cfg(test)]
100mod tests {
101 extern crate hex;
102 use super::*;
103 use crate::assert_ct_eq;
104 use anyhow::Result;
105 use hex::FromHex;
106
107 #[test]
108 fn test_encrypt() -> Result<()> {
109 let k = <[u8; 32]>::from_hex(
110 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
111 )?;
112 let p = <[u8; 32]>::from_hex(
113 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
114 )?;
115 let t_expected = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
116 let c_expected = <[u8; 32]>::from_hex(
117 "2f83f391c97f3606ccd5709c6ee15d66cd7e65a2aeb7dc3066636e8f6b0d39c3",
118 )?;
119 let (c, t) = GX::encrypt(&k, &p)?;
120 assert_eq!(&c, &c_expected);
121 assert_ct_eq!(t, &t_expected);
122 Ok(())
123 }
124
125 #[test]
126 fn test_encrypt_blob() -> Result<()> {
127 let k = <[u8; 32]>::from_hex(
128 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
129 )?;
130 let p = <[u8; 32]>::from_hex(
131 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
132 )?;
133 let blob_expected = <[u8; 48]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc652f83f391c97f3606ccd5709c6ee15d66cd7e65a2aeb7dc3066636e8f6b0d39c3")?;
134 let blob = GX::encrypt_blob(&k, &p)?;
135 assert_ct_eq!(blob, &blob_expected);
136 Ok(())
137 }
138
139 #[test]
140 fn test_decrypt_blob() -> Result<()> {
141 let k = <[u8; 32]>::from_hex(
142 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
143 )?;
144 let p_expected = <[u8; 32]>::from_hex(
145 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
146 )?;
147 let blob= <[u8; 48]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc652f83f391c97f3606ccd5709c6ee15d66cd7e65a2aeb7dc3066636e8f6b0d39c3")?;
148 let p = GX::decrypt_blob(&k, &blob)?;
149 assert_ct_eq!(&p, &p_expected);
150 Ok(())
151 }
152
153 #[test]
154 fn test_decrypt() -> Result<()> {
155 let k = <[u8; 32]>::from_hex(
156 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
157 )?;
158 let t = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
159 let c = <[u8; 32]>::from_hex(
160 "2f83f391c97f3606ccd5709c6ee15d66cd7e65a2aeb7dc3066636e8f6b0d39c3",
161 )?;
162 let p_expected = <[u8; 32]>::from_hex(
163 "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
164 )?;
165 let p = GX::decrypt(&k, &c, &t)?;
166 assert_eq!(p, p_expected);
167 Ok(())
168 }
169
170 #[test]
172 fn test_bad_decrypt() -> Result<()> {
173 let k = <[u8; 32]>::from_hex(
174 "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
175 )?;
176 let c = <[u8; 32]>::from_hex(
177 "2283f391c97f3606ccd5709c6ee15d66cd7e65a2aeb7dc3066636e8f6b0d39c3",
178 )?; let t_bad = AuthTag(<[u8; 16]>::from_hex("016325cf6a3c4b2e3b039675e1ccbc65")?);
180 let res = GX::decrypt(&k, &c, &t_bad);
181 assert!(res.is_err());
182 Ok(())
183 }
184}