Skip to main content

arx_kw/
g.rs

1use crate::{generate, lqb, util, ArxKW, ArxKwError, AuthTag, ConstantTimeEq, InvalidLengthError};
2
3/// The ARX-8-2-4-G variant. Has a key length of 32 bytes and a maximum input length of 64 bytes.
4/// See the [`ArxKW`] trait for usage.
5pub struct G;
6impl G {
7    /// The length of the secret key used by this variant of ARX-KW, in bytes
8    #[must_use]
9    pub const fn key_length() -> usize {
10        32
11    }
12
13    /// Returns the maximum length in bytes for the input to `G::encrypt`  and `G::decrypt`
14    ///
15    /// ---
16    /// This is the same for the plaintext input when encrypting and ciphertext input when
17    /// decrypting, but is **not** the same for all variants of ARX-KW. Specifically, the *E* and *G*
18    /// variants are defined only for plaintext/ciphertext inputs of no more than 512 bits, the length
19    /// of a ChaCha Block, whereas *EX* and *GX* do not have this limitation.
20    #[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")?); // first 3 hex digits should be 016
164        let res = G::decrypt(&k, &c, &t_bad);
165        assert!(res.is_err());
166        Ok(())
167    }
168}