initial commit

Signed-off-by: Kamal Tufekcic <kamal@lo.sh>

soliton/fuzz/fuzz_targets/fuzz_stream_encrypt_at.rs

@@ -0,0 +1,87 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use soliton::streaming::{stream_decrypt_init, stream_encrypt_init};
+
+fuzz_target!(|data: &[u8]| {
+    // Fuzz encrypt_chunk_at: encrypt all chunks via the random-access API,
+    // assemble in index order, then decrypt sequentially and verify round-trip.
+    //
+    // Exercises the index-derived nonce/AAD construction under adversarial
+    // plaintext, validates that out-of-order encryption produces valid streams,
+    // and confirms that size validation rejects malformed inputs without panic.
+    if data.is_empty() {
+        return;
+    }
+
+    // First byte: compression flag (bit 0), encrypt order (bit 1 = reversed).
+    let compress = data[0] & 0x01 != 0;
+    let reversed = data[0] & 0x02 != 0;
+    let plaintext = &data[1..];
+
+    let key = [0x42u8; 32];
+    let aad = b"fuzz-at";
+
+    let enc = match stream_encrypt_init(&key, aad, compress) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+
+    let header = enc.header();
+    let chunk_size = soliton::constants::STREAM_CHUNK_SIZE;
+
+    // Compute chunk boundaries.
+    let full_count = plaintext.len() / chunk_size;
+    let total_chunks = full_count + 1;
+    let mut index_order: Vec<usize> = (0..total_chunks).collect();
+    if reversed {
+        index_order.reverse();
+    }
+
+    // Encrypt each chunk via encrypt_chunk_at in the selected order.
+    let mut chunks: Vec<Option<Vec<u8>>> = vec![None; total_chunks];
+    for &i in &index_order {
+        let is_last = i == full_count;
+        let slice = if i < full_count {
+            &plaintext[i * chunk_size..(i + 1) * chunk_size]
+        } else {
+            &plaintext[full_count * chunk_size..]
+        };
+        match enc.encrypt_chunk_at(i as u64, is_last, slice) {
+            Ok(ct) => chunks[i] = Some(ct),
+            Err(_) => return,
+        }
+    }
+
+    // Assemble in index order and decrypt sequentially.
+    let mut dec = match stream_decrypt_init(&key, &header, aad) {
+        Ok(d) => d,
+        Err(_) => return,
+    };
+
+    for (i, maybe_ct) in chunks.iter().enumerate() {
+        let ct = match maybe_ct {
+            Some(c) => c,
+            None => return,
+        };
+        let is_last_expected = i == full_count;
+        match dec.decrypt_chunk(ct) {
+            Ok((pt, is_last)) => {
+                // Plaintext must match the original slice.
+                let expected = if i < full_count {
+                    &plaintext[i * chunk_size..(i + 1) * chunk_size]
+                } else {
+                    &plaintext[full_count * chunk_size..]
+                };
+                assert_eq!(&*pt, expected, "round-trip mismatch at chunk {i}");
+                assert_eq!(
+                    is_last, is_last_expected,
+                    "is_last mismatch at chunk {i}"
+                );
+                if is_last {
+                    return;
+                }
+            }
+            Err(_) => return,
+        }
+    }
+});