sframe 2.1.0

pure rust implementation of SFrame (RFC 9605)
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

use crate::{
    CipherSuite,
    crypto::buffer::{DecryptionBufferView, EncryptionBufferView},
    error::{Result, SframeError},
    header::Counter,
};

/// Trait for AEAD encryption implementations as defined in [RFC 9605 Section 4.4.3](https://www.rfc-editor.org/rfc/rfc9605.html#section-4.4.3).
pub trait AeadEncrypt: TryFrom<CipherSuite, Error = SframeError> {
    /// The secret key material this backend consumes, as produced by its
    /// [`KeyDerivation`](super::key_derivation::KeyDerivation) implementation.
    type Secret;

    /// Encrypts the plaintext in the buffer in-place.
    fn encrypt<'a, B>(&self, secret: &Self::Secret, buffer: B, counter: Counter) -> Result<()>
    where
        B: Into<EncryptionBufferView<'a>>;
}

/// Trait for AEAD decryption implementations as defined in [RFC 9605 Section 4.4.4](https://www.rfc-editor.org/rfc/rfc9605.html#section-4.4.4).
pub trait AeadDecrypt: TryFrom<CipherSuite, Error = SframeError> {
    /// The secret key material this backend consumes, as produced by its
    /// [`KeyDerivation`](super::key_derivation::KeyDerivation) implementation.
    type Secret;

    /// Decrypts the ciphertext in the buffer in-place.
    fn decrypt<'a, B>(&self, secret: &Self::Secret, buffer: B, counter: Counter) -> Result<()>
    where
        B: Into<DecryptionBufferView<'a>>;
}

#[cfg(all(test, crypto_backend))]
mod test {
    use crate::{
        CipherSuite,
        crypto::buffer::{
            DecryptionBufferView, EncryptionBufferView, encryption::EncryptionBuffer,
        },
        error::SframeError,
        header::{KeyId, SframeHeader},
        key::{DecryptionKey, EncryptionKey},
        util::test::assert_bytes_eq,
    };

    use rand::{RngExt, rng};
    use test_case::test_case;

    const KEY_MATERIAL: &str = "THIS_IS_RANDOM";

    #[test]
    fn encrypt_random_frame() {
        let mut data = vec![0u8; 1024];
        rng().fill(data.as_mut_slice());
        let header = SframeHeader::new(0, 0);
        let enc_key = EncryptionKey::derive_from(
            CipherSuite::AesGcm256Sha512,
            KeyId::default(),
            KEY_MATERIAL.as_bytes(),
        )
        .unwrap();

        let mut frame_buffer = Vec::new();
        let mut encryption_buffer = EncryptionBuffer::try_allocate(
            &mut frame_buffer,
            enc_key.cipher_suite(),
            &Vec::from(&header),
            &data,
        )
        .unwrap();
        enc_key
            .encrypt(&mut encryption_buffer, header.counter())
            .unwrap();
    }

    #[test_case(CipherSuite::AesGcm128Sha256; "AesGcm128Sha256")]
    #[test_case(CipherSuite::AesGcm256Sha512; "AesGcm256Sha512")]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_80; "AesCtr128HmacSha256_80"))]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_64; "AesCtr128HmacSha256_64"))]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_32; "AesCtr128HmacSha256_32"))]
    fn decrypt_cipher_text_shorter_than_the_auth_tag(cipher_suite: CipherSuite) {
        let dec_key =
            DecryptionKey::derive_from(cipher_suite, KeyId::default(), KEY_MATERIAL.as_bytes())
                .unwrap();
        let header = SframeHeader::new(0, 0);
        let mut aad = Vec::from(&header);
        let mut data = vec![0u8; cipher_suite.auth_tag_len() - 1];

        let decryption_buffer = DecryptionBufferView {
            aad: &mut aad,
            data: &mut data,
        };

        let result = dec_key.decrypt(decryption_buffer, header.counter());

        assert!(matches!(
            result.unwrap_err(),
            SframeError::DecryptionFailure
        ));
    }

    #[test_case(CipherSuite::AesGcm128Sha256; "AesGcm128Sha256")]
    #[test_case(CipherSuite::AesGcm256Sha512; "AesGcm256Sha512")]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_80; "AesCtr128HmacSha256_80"))]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_64; "AesCtr128HmacSha256_64"))]
    #[cfg_attr(aes_ctr, test_case(CipherSuite::AesCtr128HmacSha256_32; "AesCtr128HmacSha256_32"))]
    fn encrypt_decrypt_payload_shorter_than_the_auth_tag(cipher_suite: CipherSuite) {
        const SHORT_PAYLOAD: &[u8] = b"abc";
        assert!(SHORT_PAYLOAD.len() < cipher_suite.auth_tag_len());

        let enc_key =
            EncryptionKey::derive_from(cipher_suite, KeyId::default(), KEY_MATERIAL.as_bytes())
                .unwrap();
        let dec_key =
            DecryptionKey::derive_from(cipher_suite, KeyId::default(), KEY_MATERIAL.as_bytes())
                .unwrap();
        let header = SframeHeader::new(0, 0);

        let mut aad = Vec::from(&header);
        let mut cipher_text = SHORT_PAYLOAD.to_vec();
        let mut tag = vec![0u8; cipher_suite.auth_tag_len()];
        enc_key
            .encrypt(
                EncryptionBufferView {
                    aad: &mut aad,
                    data: &mut cipher_text,
                    tag: &mut tag,
                },
                header.counter(),
            )
            .unwrap();

        cipher_text.append(&mut tag);
        let result = dec_key.decrypt(
            DecryptionBufferView {
                aad: &mut aad,
                data: &mut cipher_text,
            },
            header.counter(),
        );

        assert!(
            result.is_ok(),
            "failed to decrypt a short payload: {result:?}"
        );
        cipher_text.truncate(cipher_text.len() - cipher_suite.auth_tag_len());
        assert_bytes_eq(&cipher_text, SHORT_PAYLOAD);
    }
}