walnut 0.1.5

# Walnut File Systwm Experimental file system with inode level encryption.
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

use std::time::{self, SystemTime};

use crc32fast::Hasher;

use crate::BLOCK_SIZE;

/// Create 32bit checksums
/// Wrapper struct around crc32fast hasher
pub struct Checksum {
    hasher: Hasher,
}

impl Checksum {
    #[inline]
    pub fn new() -> Self {
        Self {
            hasher: crc32fast::Hasher::new(),
        }
    }

    #[inline]
    pub fn update(&mut self, bytes: &[u8]) {
        self.hasher.update(bytes);
    }

    #[inline]
    pub fn finalize(self) -> u32 {
        self.hasher.finalize()
    }
}

// Calculate checksum for small objects
// For large objects please use Checksum directly
#[inline]
pub fn calculate_checksum<S>(s: &S) -> u32
where
    S: serde::Serialize,
{
    let mut hasher = Checksum::new();
    hasher.update(&bincode::serialize(&s).unwrap());
    hasher.finalize()
}

#[inline]
pub fn now() -> u64 {
    SystemTime::now()
        .duration_since(time::UNIX_EPOCH)
        .unwrap()
        .as_secs()
}

#[inline]
pub fn block_seek_position(block_index: u32) -> u32 {
    block_index * BLOCK_SIZE
}

#[inline]
pub fn encrypt(bytes: &mut [u8], lookup_table: &Vec<u8>) {
    // let len = secret.len();
    // for (index, byte) in bytes.iter_mut().enumerate() {
    //     let i = index & (len - 1);
    //     // byte.bitxor_assign(secret[i]);
    //     unsafe {
    //         *byte ^= secret.get_unchecked(i);
    //     }
    // }
    bytes
        .iter_mut()
        .zip(lookup_table)
        .for_each(|(byte, secret)| *byte ^= secret);
}

#[inline]
pub fn create_lookup_table(secret: &[u8], block_size: u32) -> Vec<u8> {
    // let mut res: Vec<u8> = Vec::with_capacity(block_size as usize);
    // unsafe { res.set_len(block_size as usize) };

    (0..block_size)
        .into_iter()
        .map(|i| secret[i as usize & (secret.len() - 1)])
        .collect()
}