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.

Examples found in repository

examples/network_mount.rs (line 100)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut cert = "certs/client.pem";
    let mut key = "certs/client-key.pem";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--cert" => {
                cert = &args[i + 1];
                i += 2;
            }
            "--key" => {
                key = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(
        addr,
        server_name,
        Path::new(cert),
        Path::new(key),
        Path::new(ca),
    )
    .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory().expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

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.