fxfs_crypto/
lib.rs

1// Copyright 2023 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use aes::cipher::generic_array::GenericArray;
6use aes::cipher::inout::InOut;
7use aes::cipher::typenum::consts::U16;
8use aes::cipher::{
9    BlockBackend, BlockClosure, BlockDecrypt, BlockEncrypt, BlockSizeUser, KeyInit, KeyIvInit,
10    StreamCipher as _, StreamCipherSeek,
11};
12use aes::Aes256;
13use anyhow::{anyhow, Error};
14use async_trait::async_trait;
15use chacha20::{self, ChaCha20};
16use fprint::TypeFingerprint;
17use futures::stream::FuturesUnordered;
18use futures::TryStreamExt as _;
19use fxfs_macros::{migrate_nodefault, Migrate};
20use serde::de::{Error as SerdeError, Visitor};
21use serde::{Deserialize, Deserializer, Serialize, Serializer};
22use static_assertions::assert_cfg;
23use std::sync::Arc;
24use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
25use zx_status as zx;
26
27pub mod ff1;
28
29pub const KEY_SIZE: usize = 256 / 8;
30pub const WRAPPED_KEY_SIZE: usize = KEY_SIZE + 16;
31// TODO(https://fxbug.dev/375700939): Support different padding sizes based on SET_ENCRYPTION_POLICY
32// flags.
33pub const FSCRYPT_PADDING: usize = 16;
34
35// Fxfs will always use a block size >= 512 bytes, so we just assume a sector size of 512 bytes,
36// which will work fine even if a different block size is used by Fxfs or the underlying device.
37const SECTOR_SIZE: u64 = 512;
38
39pub type KeyBytes = [u8; KEY_SIZE];
40
41#[derive(Debug)]
42pub struct UnwrappedKey {
43    key: KeyBytes,
44}
45
46impl UnwrappedKey {
47    pub fn new(key: KeyBytes) -> Self {
48        UnwrappedKey { key }
49    }
50
51    pub fn key(&self) -> &KeyBytes {
52        &self.key
53    }
54}
55
56pub type UnwrappedKeys = Vec<(u64, Option<UnwrappedKey>)>;
57
58pub type WrappedKeyBytes = WrappedKeyBytesV32;
59
60#[repr(transparent)]
61#[derive(Clone, Debug, PartialEq)]
62pub struct WrappedKeyBytesV32(pub [u8; WRAPPED_KEY_SIZE]);
63
64impl Default for WrappedKeyBytes {
65    fn default() -> Self {
66        Self([0u8; WRAPPED_KEY_SIZE])
67    }
68}
69
70impl TryFrom<Vec<u8>> for WrappedKeyBytes {
71    type Error = anyhow::Error;
72
73    fn try_from(buf: Vec<u8>) -> Result<Self, Self::Error> {
74        Ok(Self(buf.try_into().map_err(|_| anyhow!("wrapped key wrong length"))?))
75    }
76}
77
78impl From<[u8; WRAPPED_KEY_SIZE]> for WrappedKeyBytes {
79    fn from(buf: [u8; WRAPPED_KEY_SIZE]) -> Self {
80        Self(buf)
81    }
82}
83
84impl TypeFingerprint for WrappedKeyBytes {
85    fn fingerprint() -> String {
86        "WrappedKeyBytes".to_owned()
87    }
88}
89
90impl std::ops::Deref for WrappedKeyBytes {
91    type Target = [u8; WRAPPED_KEY_SIZE];
92    fn deref(&self) -> &Self::Target {
93        &self.0
94    }
95}
96
97impl std::ops::DerefMut for WrappedKeyBytes {
98    fn deref_mut(&mut self) -> &mut Self::Target {
99        &mut self.0
100    }
101}
102
103// Because default impls of Serialize/Deserialize for [T; N] are only defined for N in 0..=32, we
104// have to define them ourselves.
105impl Serialize for WrappedKeyBytes {
106    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
107    where
108        S: Serializer,
109    {
110        serializer.serialize_bytes(&self[..])
111    }
112}
113
114impl<'de> Deserialize<'de> for WrappedKeyBytes {
115    fn deserialize<D>(deserializer: D) -> Result<WrappedKeyBytes, D::Error>
116    where
117        D: Deserializer<'de>,
118    {
119        struct WrappedKeyVisitor;
120
121        impl<'d> Visitor<'d> for WrappedKeyVisitor {
122            type Value = WrappedKeyBytes;
123
124            fn expecting(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
125                formatter.write_str("Expected wrapped keys to be 48 bytes")
126            }
127
128            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<WrappedKeyBytes, E>
129            where
130                E: SerdeError,
131            {
132                self.visit_byte_buf(bytes.to_vec())
133            }
134
135            fn visit_byte_buf<E>(self, bytes: Vec<u8>) -> Result<WrappedKeyBytes, E>
136            where
137                E: SerdeError,
138            {
139                let orig_len = bytes.len();
140                let bytes: [u8; WRAPPED_KEY_SIZE] =
141                    bytes.try_into().map_err(|_| SerdeError::invalid_length(orig_len, &self))?;
142                Ok(WrappedKeyBytes::from(bytes))
143            }
144        }
145        deserializer.deserialize_byte_buf(WrappedKeyVisitor)
146    }
147}
148
149pub type WrappedKey = WrappedKeyV40;
150
151#[derive(Clone, Debug, Serialize, Deserialize, TypeFingerprint, PartialEq)]
152pub struct WrappedKeyV40 {
153    /// The identifier of the wrapping key.  The identifier has meaning to whatever is doing the
154    /// unwrapping.
155    pub wrapping_key_id: u128,
156    /// AES 256 requires a 512 bit key, which is made of two 256 bit keys, one for the data and one
157    /// for the tweak.  It is safe to use the same 256 bit key for both (see
158    /// https://csrc.nist.gov/CSRC/media/Projects/Block-Cipher-Techniques/documents/BCM/Comments/XTS/follow-up_XTS_comments-Ball.pdf)
159    /// which is what we do here.  Since the key is wrapped with AES-GCM-SIV, there are an
160    /// additional 16 bytes paid per key (so the actual key material is 32 bytes once unwrapped).
161    pub key: WrappedKeyBytesV32,
162}
163
164#[derive(Default, Clone, Migrate, Debug, Serialize, Deserialize, TypeFingerprint)]
165#[migrate_nodefault]
166pub struct WrappedKeyV32 {
167    pub wrapping_key_id: u64,
168    pub key: WrappedKeyBytesV32,
169}
170
171/// To support key rolling and clones, a file can have more than one key.  Each key has an ID that
172/// unique to the file.
173pub type WrappedKeys = WrappedKeysV40;
174
175#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, TypeFingerprint)]
176pub struct WrappedKeysV40(Vec<(u64, WrappedKeyV40)>);
177
178impl From<WrappedKeysV32> for WrappedKeysV40 {
179    fn from(value: WrappedKeysV32) -> Self {
180        Self(value.0.into_iter().map(|(id, key)| (id, key.into())).collect())
181    }
182}
183#[derive(Clone, Debug, Serialize, Deserialize, TypeFingerprint)]
184pub struct WrappedKeysV32(pub Vec<(u64, WrappedKeyV32)>);
185
186impl From<Vec<(u64, WrappedKey)>> for WrappedKeys {
187    fn from(buf: Vec<(u64, WrappedKey)>) -> Self {
188        Self(buf)
189    }
190}
191
192impl std::ops::Deref for WrappedKeys {
193    type Target = Vec<(u64, WrappedKey)>;
194    fn deref(&self) -> &Self::Target {
195        &self.0
196    }
197}
198
199impl std::ops::DerefMut for WrappedKeys {
200    fn deref_mut(&mut self) -> &mut Self::Target {
201        &mut self.0
202    }
203}
204
205impl WrappedKeys {
206    pub fn get_wrapping_key_with_id(&self, key_id: u64) -> Option<[u8; 16]> {
207        let wrapped_key_entry = self.0.iter().find(|(x, _)| *x == key_id);
208        wrapped_key_entry.map(|(_, wrapped_key)| wrapped_key.wrapping_key_id.to_le_bytes())
209    }
210}
211
212#[derive(Clone, Debug)]
213pub struct Cipher {
214    id: u64,
215    // This is None if the key isn't present.
216    cipher: Option<Aes256>,
217}
218
219impl Cipher {
220    pub fn new(id: u64, key: &UnwrappedKey) -> Self {
221        Self { id, cipher: Some(Aes256::new(GenericArray::from_slice(key.key()))) }
222    }
223
224    pub fn unavailable(id: u64) -> Self {
225        Cipher { id, cipher: None }
226    }
227
228    pub fn key(&self) -> Option<&Aes256> {
229        self.cipher.as_ref()
230    }
231}
232
233/// References a specific key in the cipher set.
234pub struct Key {
235    keys: Arc<CipherSet>,
236    // Index in the CipherSet array for the key.
237    index: usize,
238}
239
240impl Key {
241    pub fn new(keys: Arc<CipherSet>, index: usize) -> Self {
242        Self { keys, index }
243    }
244
245    fn key(&self) -> &Aes256 {
246        self.keys.0[self.index].cipher.as_ref().unwrap()
247    }
248
249    pub fn key_id(&self) -> u64 {
250        self.keys.0[self.index].id
251    }
252
253    /// Encrypts data in the `buffer`.
254    ///
255    /// * `offset` is the byte offset within the file.
256    /// * `buffer` is mutated in place.
257    ///
258    /// `buffer` *must* be 16 byte aligned.
259    pub fn encrypt(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Error> {
260        fxfs_trace::duration!(c"encrypt", "len" => buffer.len());
261        assert_eq!(offset % SECTOR_SIZE, 0);
262        let cipher = &self.key();
263        let mut sector_offset = offset / SECTOR_SIZE;
264        for sector in buffer.chunks_exact_mut(SECTOR_SIZE as usize) {
265            let mut tweak = Tweak(sector_offset as u128);
266            // The same key is used for encrypting the data and computing the tweak.
267            cipher.encrypt_block(GenericArray::from_mut_slice(tweak.as_mut_bytes()));
268            cipher.encrypt_with_backend(XtsProcessor::new(tweak, sector));
269            sector_offset += 1;
270        }
271        Ok(())
272    }
273
274    /// Decrypt the data in `buffer`.
275    ///
276    /// * `offset` is the byte offset within the file.
277    /// * `buffer` is mutated in place.
278    ///
279    /// `buffer` *must* be 16 byte aligned.
280    pub fn decrypt(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Error> {
281        fxfs_trace::duration!(c"decrypt", "len" => buffer.len());
282        assert_eq!(offset % SECTOR_SIZE, 0);
283        let cipher = &self.key();
284        let mut sector_offset = offset / SECTOR_SIZE;
285        for sector in buffer.chunks_exact_mut(SECTOR_SIZE as usize) {
286            let mut tweak = Tweak(sector_offset as u128);
287            // The same key is used for encrypting the data and computing the tweak.
288            cipher.encrypt_block(GenericArray::from_mut_slice(tweak.as_mut_bytes()));
289            cipher.decrypt_with_backend(XtsProcessor::new(tweak, sector));
290            sector_offset += 1;
291        }
292        Ok(())
293    }
294
295    /// Encrypts the filename contained in `buffer`.
296    pub fn encrypt_filename(&self, object_id: u64, buffer: &mut Vec<u8>) -> Result<(), Error> {
297        // Pad the buffer such that its length is a multiple of FSCRYPT_PADDING.
298        buffer.resize(buffer.len().next_multiple_of(FSCRYPT_PADDING), 0);
299        let cipher = self.key();
300        cipher.encrypt_with_backend(CbcEncryptProcessor::new(Tweak(object_id as u128), buffer));
301        Ok(())
302    }
303
304    /// Decrypts the filename contained in `buffer`.
305    pub fn decrypt_filename(&self, object_id: u64, buffer: &mut Vec<u8>) -> Result<(), Error> {
306        let cipher = self.key();
307        cipher.decrypt_with_backend(CbcDecryptProcessor::new(Tweak(object_id as u128), buffer));
308        // Remove the padding
309        if let Some(i) = buffer.iter().rposition(|x| *x != 0) {
310            let new_len = i + 1;
311            buffer.truncate(new_len);
312        }
313        Ok(())
314    }
315}
316
317#[derive(Clone, Debug)]
318pub struct CipherSet(Vec<Cipher>);
319
320impl From<Vec<Cipher>> for CipherSet {
321    fn from(value: Vec<Cipher>) -> Self {
322        Self(value)
323    }
324}
325
326impl CipherSet {
327    pub fn new(keys: &UnwrappedKeys) -> Self {
328        Self(
329            keys.iter()
330                .map(|(id, k)| match k {
331                    Some(k) => Cipher::new(*id, k),
332                    None => Cipher::unavailable(*id),
333                })
334                .collect(),
335        )
336    }
337
338    pub fn ciphers(&self) -> &[Cipher] {
339        &self.0
340    }
341
342    pub fn cipher(&self, id: u64) -> Option<(usize, &Cipher)> {
343        self.0.iter().enumerate().find(|(_, x)| x.id == id)
344    }
345
346    pub fn contains_key_id(&self, id: u64) -> bool {
347        self.0.iter().find(|x| x.id == id).is_some()
348    }
349
350    pub fn find_key(self: &Arc<Self>, id: u64) -> FindKeyResult {
351        let Some((index, cipher)) = self.0.iter().enumerate().find(|(_, x)| x.id == id) else {
352            return FindKeyResult::NotFound;
353        };
354        if cipher.key().is_some() {
355            FindKeyResult::Key(Key { keys: self.clone(), index })
356        } else {
357            FindKeyResult::Unavailable
358        }
359    }
360}
361
362pub enum FindKeyResult {
363    NotFound,
364    Unavailable,
365    Key(Key),
366}
367
368/// A thin wrapper around a ChaCha20 stream cipher.  This will use a zero nonce. **NOTE**: Great
369/// care must be taken not to encrypt different plaintext with the same key and offset (even across
370/// multiple boots), so consider if this suits your purpose before using it.
371pub struct StreamCipher(ChaCha20);
372
373impl StreamCipher {
374    pub fn new(key: &UnwrappedKey, offset: u64) -> Self {
375        let mut cipher = Self(ChaCha20::new(
376            chacha20::Key::from_slice(&key.key),
377            /* nonce: */ &[0; 12].into(),
378        ));
379        cipher.0.seek(offset);
380        cipher
381    }
382
383    pub fn encrypt(&mut self, buffer: &mut [u8]) {
384        fxfs_trace::duration!(c"StreamCipher::encrypt", "len" => buffer.len());
385        self.0.apply_keystream(buffer);
386    }
387
388    pub fn decrypt(&mut self, buffer: &mut [u8]) {
389        fxfs_trace::duration!(c"StreamCipher::decrypt", "len" => buffer.len());
390        self.0.apply_keystream(buffer);
391    }
392
393    pub fn offset(&self) -> u64 {
394        self.0.current_pos()
395    }
396}
397
398/// Different keys are used for metadata and data in order to make certain operations requiring a
399/// metadata key rotation (e.g. secure erase) more efficient.
400pub enum KeyPurpose {
401    /// The key will be used to wrap user data.
402    Data,
403    /// The key will be used to wrap internal metadata.
404    Metadata,
405}
406
407/// An interface trait with the ability to wrap and unwrap encryption keys.
408///
409/// Note that existence of this trait does not imply that an object will **securely**
410/// wrap and unwrap keys; rather just that it presents an interface for wrapping operations.
411#[async_trait]
412pub trait Crypt: Send + Sync {
413    /// `owner` is intended to be used such that when the key is wrapped, it appears to be different
414    /// to that of the same key wrapped by a different owner.  In this way, keys can be shared
415    /// amongst different filesystem objects (e.g. for clones), but it is not possible to tell just
416    /// by looking at the wrapped keys.
417    async fn create_key(
418        &self,
419        owner: u64,
420        purpose: KeyPurpose,
421    ) -> Result<(WrappedKey, UnwrappedKey), zx::Status>;
422
423    /// `owner` is intended to be used such that when the key is wrapped, it appears to be different
424    /// to that of the same key wrapped by a different owner.  In this way, keys can be shared
425    /// amongst different filesystem objects (e.g. for clones), but it is not possible to tell just
426    /// by looking at the wrapped keys.
427    async fn create_key_with_id(
428        &self,
429        owner: u64,
430        wrapping_key_id: u128,
431    ) -> Result<(WrappedKey, UnwrappedKey), zx::Status>;
432
433    // Unwraps a single key.
434    async fn unwrap_key(
435        &self,
436        wrapped_key: &WrappedKey,
437        owner: u64,
438    ) -> Result<UnwrappedKey, zx::Status>;
439
440    /// Unwraps the keys and stores the result in UnwrappedKeys.
441    async fn unwrap_keys(
442        &self,
443        keys: &WrappedKeys,
444        owner: u64,
445    ) -> Result<UnwrappedKeys, zx::Status> {
446        let futures = FuturesUnordered::new();
447        for (key_id, key) in keys.iter() {
448            futures.push(async move {
449                match self.unwrap_key(key, owner).await {
450                    Ok(unwrapped_key) => Ok((*key_id, Some(unwrapped_key))),
451                    Err(zx::Status::NOT_FOUND) => Ok((*key_id, None)),
452                    Err(e) => Err(e),
453                }
454            });
455        }
456        Ok(futures.try_collect::<UnwrappedKeys>().await?)
457    }
458}
459
460// This assumes little-endianness which is likely to always be the case.
461assert_cfg!(target_endian = "little");
462#[derive(IntoBytes, KnownLayout, FromBytes, Immutable)]
463#[repr(C)]
464struct Tweak(u128);
465
466pub fn xor_in_place(a: &mut [u8], b: &[u8]) {
467    for (b1, b2) in a.iter_mut().zip(b.iter()) {
468        *b1 ^= *b2;
469    }
470}
471
472// To be used with encrypt_with_backend.
473struct CbcEncryptProcessor<'a> {
474    tweak: Tweak,
475    data: &'a mut [u8],
476}
477
478impl<'a> CbcEncryptProcessor<'a> {
479    fn new(tweak: Tweak, data: &'a mut [u8]) -> Self {
480        Self { tweak, data }
481    }
482}
483
484impl BlockSizeUser for CbcEncryptProcessor<'_> {
485    type BlockSize = U16;
486}
487
488impl BlockClosure for CbcEncryptProcessor<'_> {
489    fn call<B: BlockBackend<BlockSize = Self::BlockSize>>(self, backend: &mut B) {
490        let Self { mut tweak, data } = self;
491        for block in data.chunks_exact_mut(16) {
492            xor_in_place(block, &tweak.0.to_le_bytes());
493            let chunk: &mut GenericArray<u8, _> = GenericArray::from_mut_slice(block);
494            backend.proc_block(InOut::from(chunk));
495            tweak.0 = u128::from_le_bytes(block.try_into().unwrap())
496        }
497    }
498}
499
500// To be used with decrypt_with_backend.
501struct CbcDecryptProcessor<'a> {
502    tweak: Tweak,
503    data: &'a mut [u8],
504}
505
506impl<'a> CbcDecryptProcessor<'a> {
507    fn new(tweak: Tweak, data: &'a mut [u8]) -> Self {
508        Self { tweak, data }
509    }
510}
511
512impl BlockSizeUser for CbcDecryptProcessor<'_> {
513    type BlockSize = U16;
514}
515
516impl BlockClosure for CbcDecryptProcessor<'_> {
517    fn call<B: BlockBackend<BlockSize = Self::BlockSize>>(self, backend: &mut B) {
518        let Self { mut tweak, data } = self;
519        for block in data.chunks_exact_mut(16) {
520            let ciphertext = block.to_vec();
521            let chunk = GenericArray::from_mut_slice(block);
522            backend.proc_block(InOut::from(chunk));
523            xor_in_place(block, &tweak.0.to_le_bytes());
524            tweak.0 = u128::from_le_bytes(ciphertext.try_into().unwrap());
525        }
526    }
527}
528
529// To be used with encrypt|decrypt_with_backend.
530struct XtsProcessor<'a> {
531    tweak: Tweak,
532    data: &'a mut [u8],
533}
534
535impl<'a> XtsProcessor<'a> {
536    // `tweak` should be encrypted.  `data` should be a single sector and *must* be 16 byte aligned.
537    fn new(tweak: Tweak, data: &'a mut [u8]) -> Self {
538        assert_eq!(data.as_ptr() as usize & 15, 0, "data must be 16 byte aligned");
539        Self { tweak, data }
540    }
541}
542
543impl BlockSizeUser for XtsProcessor<'_> {
544    type BlockSize = U16;
545}
546
547impl BlockClosure for XtsProcessor<'_> {
548    fn call<B: BlockBackend<BlockSize = Self::BlockSize>>(self, backend: &mut B) {
549        let Self { mut tweak, data } = self;
550        for chunk in data.chunks_exact_mut(16) {
551            let ptr = chunk.as_mut_ptr() as *mut u128;
552            // SAFETY: We know each chunk is exactly 16 bytes and it should be safe to transmute to
553            // u128 and GenericArray<u8, U16>.  There are safe ways of doing the following, but this
554            // is extremely performance sensitive, and even seemingly innocuous changes here can
555            // have an order-of-magnitude impact on what the compiler produces and that can be seen
556            // in our benchmarks.  This assumes little-endianness which is likely to always be the
557            // case.
558            unsafe {
559                *ptr ^= tweak.0;
560                let chunk = ptr as *mut GenericArray<u8, U16>;
561                backend.proc_block(InOut::from_raw(chunk, chunk));
562                *ptr ^= tweak.0;
563            }
564            tweak.0 = (tweak.0 << 1) ^ ((tweak.0 as i128 >> 127) as u128 & 0x87);
565        }
566    }
567}
568
569#[cfg(test)]
570mod tests {
571    use crate::{Cipher, CipherSet, Key};
572
573    use super::{StreamCipher, UnwrappedKey};
574
575    #[test]
576    fn test_stream_cipher_offset() {
577        let key = UnwrappedKey::new([
578            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
579            25, 26, 27, 28, 29, 30, 31, 32,
580        ]);
581        let mut cipher1 = StreamCipher::new(&key, 0);
582        let mut p1 = [1, 2, 3, 4];
583        let mut c1 = p1.clone();
584        cipher1.encrypt(&mut c1);
585
586        let mut cipher2 = StreamCipher::new(&key, 1);
587        let p2 = [5, 6, 7, 8];
588        let mut c2 = p2.clone();
589        cipher2.encrypt(&mut c2);
590
591        let xor_fn = |buf1: &mut [u8], buf2| {
592            for (b1, b2) in buf1.iter_mut().zip(buf2) {
593                *b1 ^= b2;
594            }
595        };
596
597        // Check that c1 ^ c2 != p1 ^ p2 (which would be the case if the same offset was used for
598        // both ciphers).
599        xor_fn(&mut c1, &c2);
600        xor_fn(&mut p1, &p2);
601        assert_ne!(c1, p1);
602    }
603
604    /// Output produced via:
605    /// echo -n filename > in.txt ; truncate -s 16 in.txt
606    /// openssl aes-256-cbc -e -iv 02000000000000000000000000000000 -nosalt -K 1fcdf30b7d191bd95d3161fe08513b864aa15f27f910f1c66eec8cfa93e9893b -in in.txt -out out.txt -nopad
607    /// hexdump out.txt -e "16/1 \"%02x\" \"\n\"" -v
608    #[test]
609    fn test_encrypt_filename() {
610        let raw_key_hex = "1fcdf30b7d191bd95d3161fe08513b864aa15f27f910f1c66eec8cfa93e9893b";
611        let raw_key_bytes: [u8; 32] =
612            hex::decode(raw_key_hex).expect("decode failed").try_into().unwrap();
613        let unwrapped_key = UnwrappedKey::new(raw_key_bytes);
614        let cipher_set = CipherSet::from(vec![Cipher::new(0, &unwrapped_key)]);
615        let key = Key { keys: std::sync::Arc::new(cipher_set), index: 0 };
616        let object_id = 2;
617        let mut text = "filename".to_string().as_bytes().to_vec();
618        key.encrypt_filename(object_id, &mut text).expect("encrypt filename failed");
619        assert_eq!(text, hex::decode("52d56369103a39b3ea1e09c85dd51546").expect("decode failed"));
620    }
621
622    /// Output produced via:
623    /// openssl aes-256-cbc -d -iv 02000000000000000000000000000000 -nosalt -K 1fcdf30b7d191bd95d3161fe08513b864aa15f27f910f1c66eec8cfa93e9893b -in out.txt -out in.txt
624    /// cat in.txt
625    #[test]
626    fn test_decrypt_filename() {
627        let raw_key_hex = "1fcdf30b7d191bd95d3161fe08513b864aa15f27f910f1c66eec8cfa93e9893b";
628        let raw_key_bytes: [u8; 32] =
629            hex::decode(raw_key_hex).expect("decode failed").try_into().unwrap();
630        let unwrapped_key = UnwrappedKey::new(raw_key_bytes);
631        let cipher_set = CipherSet::from(vec![Cipher::new(0, &unwrapped_key)]);
632        let key = Key { keys: std::sync::Arc::new(cipher_set), index: 0 };
633        let object_id = 2;
634        let mut text = hex::decode("52d56369103a39b3ea1e09c85dd51546").expect("decode failed");
635        key.decrypt_filename(object_id, &mut text).expect("encrypt filename failed");
636        assert_eq!(text, "filename".to_string().as_bytes().to_vec());
637    }
638}
fxfs_crypto/lib.rs

fxfs_crypto/
lib.rs
