Struct ChaChaEngine 

pub struct ChaChaEngine { /* private fields */ }

ChaCha20-Poly1305 based crypto engine. Derives the actual encryption key from a master key using HKDF.

Implementations

impl ChaChaEngine

pub fn new(master_key: &[u8]) -> FsResult<Self>

Create from a raw master key. The encryption key is derived via HKDF-SHA256.

pub fn generate() -> FsResult<Self>

Convenience: create with a randomly generated master key (for testing / new FS).

Examples found in repository

examples/create_image.rs (line 32)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

Trait Implementations

impl CryptoEngine for ChaChaEngine

fn encrypt(&self, plaintext: &[u8]) -> FsResult<(Vec<u8>, Vec<u8>)>

Encrypt plaintext into ciphertext with a nonce. Returns (nonce, ciphertext).

fn decrypt(&self, nonce: &[u8], ciphertext: &[u8]) -> FsResult<Vec<u8>>

Decrypt ciphertext with the given nonce. Returns plaintext.

impl Drop for ChaChaEngine

fn drop(&mut self)

Executes the destructor for this type.