roxify 1.11.1 → 1.12.0

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.11.1"
+version = "1.12.0"
 edition = "2021"
 publish = false
 
@@ -43,6 +43,10 @@ image = { version = "0.25", default-features = false, features = ["png"] }
 walkdir = "2.5.0"
 tar = "0.4"
 aes-gcm = "0.10"
+aes = "0.8"
+ctr = "0.9"
+cipher = { version = "0.4", features = ["std"] }
+hmac = "0.12"
 pbkdf2 = "0.12"
 rand = "0.8"
 sha2 = "0.10"

package/dist/cli.js

@@ -6,7 +6,7 @@ import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInP
 import { packPathsGenerator, unpackBuffer } from './pack.js';
 import * as cliProgress from './stub-progress.js';
 import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.9.2';
+const VERSION = '1.12.0';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {

package/native/crypto.rs

@@ -7,9 +7,17 @@ use pbkdf2::pbkdf2_hmac;
 use rand::RngCore;
 use sha2::Sha256;
 
+use aes::Aes256;
+use cipher::{KeyIvInit, StreamCipher};
+use hmac::{Hmac, Mac};
+
+type Aes256Ctr = ctr::Ctr64BE<Aes256>;
+type HmacSha256 = Hmac<Sha256>;
+
 const ENC_NONE: u8 = 0x00;
 const ENC_AES: u8 = 0x01;
 const ENC_XOR: u8 = 0x02;
+const ENC_AES_CTR: u8 = 0x03;
 const PBKDF2_ITERS: u32 = 600_000;
 
 pub fn encrypt_xor(data: &[u8], passphrase: &str) -> Vec<u8> {
@@ -114,6 +122,83 @@ pub fn try_decrypt(buf: &[u8], passphrase: Option<&str>) -> Result<Vec<u8>> {
             let pass = passphrase.ok_or_else(|| anyhow!("Passphrase required for AES decryption"))?;
             decrypt_aes(buf, pass)
         }
+        ENC_AES_CTR => {
+            let pass = passphrase.ok_or_else(|| anyhow!("Passphrase required for AES-CTR decryption"))?;
+            decrypt_aes_ctr(buf, pass)
+        }
         _ => Err(anyhow!("Unknown encryption flag: {}", flag)),
     }
 }
+
+pub fn derive_aes_ctr_key(passphrase: &str, salt: &[u8]) -> [u8; 32] {
+    let mut key = [0u8; 32];
+    pbkdf2_hmac::<Sha256>(passphrase.as_bytes(), salt, PBKDF2_ITERS, &mut key);
+    key
+}
+
+pub struct StreamingEncryptor {
+    cipher: Aes256Ctr,
+    hmac: HmacSha256,
+    pub header: Vec<u8>,
+}
+
+impl StreamingEncryptor {
+    pub fn new(passphrase: &str) -> Result<Self> {
+        let mut salt = [0u8; 16];
+        rand::thread_rng().fill_bytes(&mut salt);
+        let mut iv = [0u8; 16];
+        rand::thread_rng().fill_bytes(&mut iv);
+
+        let key = derive_aes_ctr_key(passphrase, &salt);
+        let cipher = Aes256Ctr::new_from_slices(&key, &iv)
+            .map_err(|e| anyhow!("AES-CTR init: {}", e))?;
+        let hmac = <HmacSha256 as Mac>::new_from_slice(&key)
+            .map_err(|e| anyhow!("HMAC init: {}", e))?;
+
+        let mut header = Vec::with_capacity(1 + 16 + 16);
+        header.push(ENC_AES_CTR);
+        header.extend_from_slice(&salt);
+        header.extend_from_slice(&iv);
+
+        Ok(Self { cipher, hmac, header })
+    }
+
+    pub fn header_len(&self) -> usize {
+        self.header.len()
+    }
+
+    pub fn encrypt_chunk(&mut self, buf: &mut [u8]) {
+        self.cipher.apply_keystream(buf);
+        self.hmac.update(buf);
+    }
+
+    pub fn finalize_hmac(self) -> [u8; 32] {
+        let result = self.hmac.finalize();
+        result.into_bytes().into()
+    }
+}
+
+pub fn decrypt_aes_ctr(data: &[u8], passphrase: &str) -> Result<Vec<u8>> {
+    if data.len() < 1 + 16 + 16 + 32 {
+        return Err(anyhow!("Invalid AES-CTR payload length"));
+    }
+    let salt = &data[1..17];
+    let iv = &data[17..33];
+    let hmac_tag = &data[data.len() - 32..];
+    let ciphertext = &data[33..data.len() - 32];
+
+    let key = derive_aes_ctr_key(passphrase, salt);
+
+    let mut mac = <HmacSha256 as Mac>::new_from_slice(&key)
+        .map_err(|e| anyhow!("HMAC init: {}", e))?;
+    mac.update(ciphertext);
+    mac.verify_slice(hmac_tag)
+        .map_err(|_| anyhow!("HMAC verification failed - wrong passphrase or corrupted data"))?;
+
+    let mut decrypted = ciphertext.to_vec();
+    let mut cipher = Aes256Ctr::new_from_slices(&key, iv)
+        .map_err(|e| anyhow!("AES-CTR init: {}", e))?;
+    cipher.apply_keystream(&mut decrypted);
+
+    Ok(decrypted)
+}

package/native/encoder.rs

@@ -226,12 +226,11 @@ fn encode_to_png_with_encryption_name_and_filelist_internal(
 
 fn build_flat_pixel_buffer(
     meta_pixel: &[u8],
-    padding_needed: usize,
+    _padding_needed: usize,
     marker_end_pos: usize,
     marker_end_len: usize,
     total_data_bytes: usize,
 ) -> Vec<u8> {
-    let header_len = 12 + PIXEL_MAGIC.len() + meta_pixel.len() + padding_needed;
     let mut flat = vec![0u8; total_data_bytes];
 
     let mut pos = 0;
@@ -246,7 +245,6 @@ fn build_flat_pixel_buffer(
     pos += PIXEL_MAGIC.len();
 
     flat[pos..pos + meta_pixel.len()].copy_from_slice(meta_pixel);
-    pos += meta_pixel.len();
 
     if marker_end_pos + marker_end_len <= total_data_bytes {
         for (i, m) in MARKER_END.iter().enumerate() {

package/native/main.rs

@@ -15,6 +15,8 @@ mod audio;
 mod reconstitution;
 mod archive;
 mod streaming;
+mod streaming_decode;
+mod streaming_encode;
 
 use crate::encoder::ImageFormat;
 use std::path::PathBuf;
@@ -157,6 +159,23 @@ fn main() -> anyhow::Result<()> {
         }
         Commands::Encode { input, output, level, passphrase, encrypt, name, dict } => {
             let is_dir = input.is_dir();
+
+            let file_name = name.as_deref()
+                .or_else(|| input.file_name().and_then(|n| n.to_str()));
+
+            if is_dir && dict.is_none() {
+                streaming_encode::encode_dir_to_png_encrypted(
+                    &input,
+                    &output,
+                    level,
+                    file_name,
+                    passphrase.as_deref(),
+                    Some(&encrypt),
+                )?;
+                println!("(TAR archive, rXFL chunk embedded)");
+                return Ok(());
+            }
+
             let (payload, file_list_json) = if is_dir {
                 let result = archive::tar_pack_directory_with_list(&input)
                     .map_err(|e| anyhow::anyhow!(e))?;
@@ -169,9 +188,6 @@ fn main() -> anyhow::Result<()> {
                 (pack_result.data, pack_result.file_list_json)
             };
 
-            let file_name = name.as_deref()
-                .or_else(|| input.file_name().and_then(|n| n.to_str()));
-
             let dict_bytes: Option<Vec<u8>> = match dict {
                 Some(path) => Some(read_all(&path)?),
                 None => None,
@@ -272,13 +288,13 @@ fn main() -> anyhow::Result<()> {
             let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
             if is_png {
                 let payload = png_utils::extract_payload_from_png(&buf).map_err(|e| anyhow::anyhow!(e))?;
-                if !payload.is_empty() && (payload[0] == 0x01 || payload[0] == 0x02) {
+                if !payload.is_empty() && (payload[0] == 0x01 || payload[0] == 0x02 || payload[0] == 0x03) {
                     println!("Passphrase detected.");
                 } else {
                     println!("No passphrase detected.");
                 }
             } else {
-                if !buf.is_empty() && (buf[0] == 0x01 || buf[0] == 0x02) {
+                if !buf.is_empty() && (buf[0] == 0x01 || buf[0] == 0x02 || buf[0] == 0x03) {
                     println!("Passphrase detected.");
                 } else {
                     println!("No passphrase detected.");
@@ -320,6 +336,27 @@ fn main() -> anyhow::Result<()> {
             write_all(&dest, &out)?;
         }
         Commands::Decompress { input, output, files, passphrase, dict } => {
+            let file_size = std::fs::metadata(&input).map(|m| m.len()).unwrap_or(0);
+            let is_png_file = input.extension().map(|e| e == "png").unwrap_or(false)
+                || (file_size >= 8 && {
+                    let mut sig = [0u8; 8];
+                    std::fs::File::open(&input).and_then(|mut f| { use std::io::Read; f.read_exact(&mut sig) }).is_ok()
+                        && sig == [137, 80, 78, 71, 13, 10, 26, 10]
+                });
+
+            if is_png_file && files.is_none() && dict.is_none() && file_size > 100_000_000 {
+                let out_dir = output.clone().unwrap_or_else(|| PathBuf::from("out.raw"));
+                match streaming_decode::streaming_decode_to_dir_encrypted(&input, &out_dir, passphrase.as_deref()) {
+                    Ok(written) => {
+                        println!("Unpacked {} files (TAR)", written.len());
+                        return Ok(());
+                    }
+                    Err(e) => {
+                        eprintln!("Streaming decode failed ({}), falling back to in-memory", e);
+                    }
+                }
+            }
+
             let buf = read_all(&input)?;
             let dict_bytes: Option<Vec<u8>> = match dict {
                 Some(path) => Some(read_all(&path)?),
@@ -359,7 +396,7 @@ fn main() -> anyhow::Result<()> {
                         buf[1..].to_vec()
                     } else if buf.starts_with(b"ROX1") {
                         buf[4..].to_vec()
-                    } else if buf[0] == 0x01u8 || buf[0] == 0x02u8 {
+                    } else if buf[0] == 0x01u8 || buf[0] == 0x02u8 || buf[0] == 0x03u8 {
                         let pass = passphrase.as_ref().map(|s: &String| s.as_str());
                         match crate::crypto::try_decrypt(&buf, pass) {
                             Ok(v) => v,

package/native/png_utils.rs

@@ -174,7 +174,7 @@ pub fn extract_payload_from_png(png_data: &[u8]) -> Result<Vec<u8>, String> {
 
 fn validate_payload_deep(payload: &[u8]) -> bool {
     if payload.len() < 5 { return false; }
-    if payload[0] == 0x01 || payload[0] == 0x02 { return true; }
+    if payload[0] == 0x01 || payload[0] == 0x02 || payload[0] == 0x03 { return true; }
     let compressed = if payload[0] == 0x00 { &payload[1..] } else { payload };
     if compressed.starts_with(b"ROX1") { return true; }
     crate::core::zstd_decompress_bytes(compressed, None).is_ok()

package/native/streaming_decode.rs

@@ -0,0 +1,338 @@
+use std::io::Read;
+use std::path::Path;
+use cipher::{KeyIvInit, StreamCipher};
+
+const PIXEL_MAGIC: &[u8] = b"PXL1";
+const MARKER_BYTES: usize = 12;
+
+type Aes256Ctr = ctr::Ctr64BE<aes::Aes256>;
+
+pub fn streaming_decode_to_dir(png_path: &Path, out_dir: &Path) -> Result<Vec<String>, String> {
+    streaming_decode_to_dir_encrypted(png_path, out_dir, None)
+}
+
+pub fn streaming_decode_to_dir_encrypted(
+    png_path: &Path,
+    out_dir: &Path,
+    passphrase: Option<&str>,
+) -> Result<Vec<String>, String> {
+    let file = std::fs::File::open(png_path).map_err(|e| format!("open: {}", e))?;
+    let mmap = unsafe { memmap2::Mmap::map(&file).map_err(|e| format!("mmap: {}", e))? };
+    let data = &mmap[..];
+
+    if data.len() < 8 || &data[0..8] != &[137, 80, 78, 71, 13, 10, 26, 10] {
+        return Err("Not a PNG file".into());
+    }
+
+    let (width, height, idat_data_start, idat_data_end) = parse_png_header(data)?;
+
+    let mut reader = DeflatePixelReader::new(data, width, height, idat_data_start, idat_data_end);
+
+    let mut marker_buf = [0u8; MARKER_BYTES];
+    reader.read_exact(&mut marker_buf).map_err(|e| format!("read markers: {}", e))?;
+
+    let mut pxl1 = [0u8; 4];
+    reader.read_exact(&mut pxl1).map_err(|e| format!("read PXL1: {}", e))?;
+    if &pxl1 != PIXEL_MAGIC {
+        return Err(format!("Expected PXL1, got {:?}", pxl1));
+    }
+
+    let mut hdr = [0u8; 2];
+    reader.read_exact(&mut hdr).map_err(|e| format!("read hdr: {}", e))?;
+    let _version = hdr[0];
+    let name_len = hdr[1] as usize;
+
+    if name_len > 0 {
+        let mut name_buf = vec![0u8; name_len];
+        reader.read_exact(&mut name_buf).map_err(|e| format!("read name: {}", e))?;
+    }
+
+    let mut plen_buf = [0u8; 4];
+    reader.read_exact(&mut plen_buf).map_err(|e| format!("read payload_len: {}", e))?;
+    let payload_len = u32::from_be_bytes(plen_buf) as u64;
+
+    let payload_reader = reader.take(payload_len);
+
+    let first_byte_reader = FirstByteReader::new(payload_reader);
+    let (enc_byte, remaining_reader) = first_byte_reader.into_parts()?;
+
+    match enc_byte {
+        0x00 => {
+            let mut decoder = zstd::stream::Decoder::new(remaining_reader)
+                .map_err(|e| format!("zstd decoder: {}", e))?;
+            decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max: {}", e))?;
+            read_rox1_and_untar(decoder, out_dir)
+        }
+        0x03 => {
+            let pass = passphrase.ok_or("Passphrase required for AES-CTR decryption")?;
+            let mut salt = [0u8; 16];
+            let mut iv = [0u8; 16];
+            let mut r = remaining_reader;
+            r.read_exact(&mut salt).map_err(|e| format!("read salt: {}", e))?;
+            r.read_exact(&mut iv).map_err(|e| format!("read iv: {}", e))?;
+
+            let key = crate::crypto::derive_aes_ctr_key(pass, &salt);
+            let cipher = Aes256Ctr::new_from_slices(&key, &iv)
+                .map_err(|e| format!("AES-CTR init: {}", e))?;
+
+            let hmac_size = 32u64;
+            let encrypted_data_len = payload_len - 1 - 16 - 16 - hmac_size;
+            let ctr_reader = CtrDecryptReader::new(r.take(encrypted_data_len), cipher);
+
+            let mut decoder = zstd::stream::Decoder::new(ctr_reader)
+                .map_err(|e| format!("zstd decoder: {}", e))?;
+            decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max: {}", e))?;
+            read_rox1_and_untar(decoder, out_dir)
+        }
+        _ => Err(format!("Unsupported encryption (enc=0x{:02x}) in streaming decode", enc_byte)),
+    }
+}
+
+fn read_rox1_and_untar<R: Read>(mut decoder: R, out_dir: &Path) -> Result<Vec<String>, String> {
+    let mut magic = [0u8; 4];
+    decoder.read_exact(&mut magic).map_err(|e| format!("read ROX1: {}", e))?;
+    if &magic != b"ROX1" {
+        return Err(format!("Expected ROX1, got {:?}", magic));
+    }
+    std::fs::create_dir_all(out_dir).map_err(|e| format!("mkdir: {}", e))?;
+    tar_unpack_from_reader(decoder, out_dir)
+}
+
+fn parse_png_header(data: &[u8]) -> Result<(usize, usize, usize, usize), String> {
+    let mut pos = 8;
+
+    let mut width = 0usize;
+    let mut height = 0usize;
+    let mut idat_start = 0usize;
+    let mut idat_end = 0usize;
+
+    while pos + 12 <= data.len() {
+        let chunk_len = u32::from_be_bytes([data[pos], data[pos + 1], data[pos + 2], data[pos + 3]]) as usize;
+        let chunk_type = &data[pos + 4..pos + 8];
+        let chunk_data_start = pos + 8;
+
+        if chunk_type == b"IHDR" {
+            if chunk_len < 13 {
+                return Err("Invalid IHDR".into());
+            }
+            width = u32::from_be_bytes([
+                data[chunk_data_start],
+                data[chunk_data_start + 1],
+                data[chunk_data_start + 2],
+                data[chunk_data_start + 3],
+            ]) as usize;
+            height = u32::from_be_bytes([
+                data[chunk_data_start + 4],
+                data[chunk_data_start + 5],
+                data[chunk_data_start + 6],
+                data[chunk_data_start + 7],
+            ]) as usize;
+        } else if chunk_type == b"IDAT" {
+            idat_start = chunk_data_start;
+            idat_end = chunk_data_start + chunk_len;
+        } else if chunk_type == b"IEND" {
+            break;
+        }
+
+        pos = chunk_data_start + chunk_len + 4;
+    }
+
+    if width == 0 || height == 0 {
+        return Err("IHDR not found".into());
+    }
+    if idat_start == 0 {
+        return Err("IDAT not found".into());
+    }
+
+    Ok((width, height, idat_start, idat_end))
+}
+
+struct DeflatePixelReader<'a> {
+    data: &'a [u8],
+    height: usize,
+    offset: usize,
+    idat_end: usize,
+    block_remaining: usize,
+    current_row: usize,
+    col_in_row: usize,
+    scanline_filter_pending: bool,
+    row_bytes: usize,
+}
+
+impl<'a> DeflatePixelReader<'a> {
+    fn new(data: &'a [u8], width: usize, height: usize, idat_data_start: usize, idat_data_end: usize) -> Self {
+        let row_bytes = width * 3;
+        Self {
+            data,
+            height,
+            offset: idat_data_start + 2,
+            idat_end: idat_data_end,
+            block_remaining: 0,
+            current_row: 0,
+            col_in_row: 0,
+            scanline_filter_pending: true,
+            row_bytes,
+        }
+    }
+
+    fn ensure_block(&mut self) -> Result<(), std::io::Error> {
+        if self.block_remaining > 0 {
+            return Ok(());
+        }
+
+        if self.offset + 5 > self.idat_end {
+            return Err(std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "No more deflate blocks"));
+        }
+
+        let len_lo = self.data[self.offset + 1] as usize;
+        let len_hi = self.data[self.offset + 2] as usize;
+        self.offset += 5;
+
+        self.block_remaining = len_lo | (len_hi << 8);
+        Ok(())
+    }
+
+    fn copy_raw_bytes(&mut self, buf: &mut [u8], count: usize) -> Result<usize, std::io::Error> {
+        let mut written = 0;
+        while written < count {
+            self.ensure_block()?;
+            let avail = self.block_remaining.min(count - written).min(self.idat_end - self.offset);
+            if avail == 0 {
+                break;
+            }
+            buf[written..written + avail].copy_from_slice(&self.data[self.offset..self.offset + avail]);
+            self.offset += avail;
+            self.block_remaining -= avail;
+            written += avail;
+        }
+        Ok(written)
+    }
+
+    fn skip_raw_bytes(&mut self, count: usize) -> Result<(), std::io::Error> {
+        let mut remaining = count;
+        while remaining > 0 {
+            self.ensure_block()?;
+            let skip = self.block_remaining.min(remaining).min(self.idat_end - self.offset);
+            if skip == 0 {
+                break;
+            }
+            self.offset += skip;
+            self.block_remaining -= skip;
+            remaining -= skip;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> Read for DeflatePixelReader<'a> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let mut filled = 0;
+
+        while filled < buf.len() {
+            if self.current_row >= self.height {
+                break;
+            }
+
+            if self.scanline_filter_pending {
+                self.skip_raw_bytes(1)?;
+                self.scanline_filter_pending = false;
+                self.col_in_row = 0;
+            }
+
+            if self.col_in_row >= self.row_bytes {
+                self.current_row += 1;
+                self.scanline_filter_pending = true;
+                continue;
+            }
+
+            let remaining_in_row = self.row_bytes - self.col_in_row;
+            let remaining_in_buf = buf.len() - filled;
+            let to_read = remaining_in_row.min(remaining_in_buf);
+
+            let got = self.copy_raw_bytes(&mut buf[filled..filled + to_read], to_read)?;
+            filled += got;
+            self.col_in_row += got;
+            if got == 0 {
+                break;
+            }
+        }
+
+        Ok(filled)
+    }
+}
+
+struct FirstByteReader<R: Read> {
+    inner: R,
+}
+
+impl<R: Read> FirstByteReader<R> {
+    fn new(inner: R) -> Self {
+        Self { inner }
+    }
+
+    fn into_parts(mut self) -> Result<(u8, impl Read), String> {
+        let mut byte = [0u8; 1];
+        self.inner.read_exact(&mut byte).map_err(|e| format!("read first byte: {}", e))?;
+        Ok((byte[0], self.inner))
+    }
+}
+
+struct CtrDecryptReader<R: Read> {
+    inner: R,
+    cipher: Aes256Ctr,
+}
+
+impl<R: Read> CtrDecryptReader<R> {
+    fn new(inner: R, cipher: Aes256Ctr) -> Self {
+        Self { inner, cipher }
+    }
+}
+
+impl<R: Read> Read for CtrDecryptReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let n = self.inner.read(buf)?;
+        if n > 0 {
+            self.cipher.apply_keystream(&mut buf[..n]);
+        }
+        Ok(n)
+    }
+}
+
+fn tar_unpack_from_reader<R: Read>(reader: R, output_dir: &Path) -> Result<Vec<String>, String> {
+    let buf_reader = std::io::BufReader::with_capacity(8 * 1024 * 1024, reader);
+    let mut archive = tar::Archive::new(buf_reader);
+    let mut written = Vec::new();
+    let mut created_dirs = std::collections::HashSet::new();
+
+    let entries = archive.entries().map_err(|e| format!("tar entries: {}", e))?;
+    for entry in entries {
+        let mut entry = entry.map_err(|e| format!("tar entry: {}", e))?;
+        let path = entry.path().map_err(|e| format!("tar path: {}", e))?.to_path_buf();
+
+        let mut safe = std::path::PathBuf::new();
+        for comp in path.components() {
+            if let std::path::Component::Normal(osstr) = comp {
+                safe.push(osstr);
+            }
+        }
+        if safe.as_os_str().is_empty() {
+            continue;
+        }
+
+        let dest = output_dir.join(&safe);
+        if let Some(parent) = dest.parent() {
+            if created_dirs.insert(parent.to_path_buf()) {
+                std::fs::create_dir_all(parent).map_err(|e| format!("mkdir {:?}: {}", parent, e))?;
+            }
+        }
+
+        let mut f = std::io::BufWriter::with_capacity(
+            (entry.size() as usize).min(4 * 1024 * 1024).max(8192),
+            std::fs::File::create(&dest).map_err(|e| format!("create {:?}: {}", dest, e))?,
+        );
+        std::io::copy(&mut entry, &mut f).map_err(|e| format!("write {:?}: {}", dest, e))?;
+        written.push(safe.to_string_lossy().to_string());
+    }
+
+    Ok(written)
+}

package/native/streaming_encode.rs

@@ -0,0 +1,494 @@
+use std::io::{Write, BufWriter, Read};
+use std::fs::File;
+use std::path::Path;
+use walkdir::WalkDir;
+use tar::{Builder, Header};
+
+const PNG_HEADER: &[u8] = &[137, 80, 78, 71, 13, 10, 26, 10];
+const PIXEL_MAGIC: &[u8] = b"PXL1";
+const MARKER_START: [(u8, u8, u8); 3] = [(255, 0, 0), (0, 255, 0), (0, 0, 255)];
+const MARKER_END: [(u8, u8, u8); 3] = [(0, 0, 255), (0, 255, 0), (255, 0, 0)];
+const MARKER_ZSTD: (u8, u8, u8) = (0, 255, 0);
+const MAGIC: &[u8] = b"ROX1";
+
+pub fn encode_dir_to_png(
+    dir_path: &Path,
+    output_path: &Path,
+    compression_level: i32,
+    name: Option<&str>,
+) -> anyhow::Result<()> {
+    encode_dir_to_png_encrypted(dir_path, output_path, compression_level, name, None, None)
+}
+
+pub fn encode_dir_to_png_encrypted(
+    dir_path: &Path,
+    output_path: &Path,
+    compression_level: i32,
+    name: Option<&str>,
+    passphrase: Option<&str>,
+    encrypt_type: Option<&str>,
+) -> anyhow::Result<()> {
+    let tmp_zst = output_path.with_extension("tmp.zst");
+
+    let file_list = compress_dir_to_zst(dir_path, &tmp_zst, compression_level)?;
+    let file_list_json = serde_json::to_string(&file_list)?;
+
+    let result = write_png_from_zst(
+        &tmp_zst, output_path, name, Some(&file_list_json),
+        passphrase, encrypt_type,
+    );
+    let _ = std::fs::remove_file(&tmp_zst);
+    result
+}
+
+fn compress_dir_to_zst(
+    dir_path: &Path,
+    zst_path: &Path,
+    compression_level: i32,
+) -> anyhow::Result<Vec<serde_json::Value>> {
+    let base = dir_path;
+
+    let entries: Vec<_> = WalkDir::new(dir_path)
+        .follow_links(false)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_type().is_file())
+        .collect();
+
+    let zst_file = File::create(zst_path)?;
+    let buf_writer = BufWriter::with_capacity(16 * 1024 * 1024, zst_file);
+
+    let actual_level = compression_level.min(3);
+    let mut encoder = zstd::stream::Encoder::new(buf_writer, actual_level)
+        .map_err(|e| anyhow::anyhow!("zstd init: {}", e))?;
+
+    let threads = num_cpus::get() as u32;
+    if threads > 1 {
+        let _ = encoder.multithread(threads);
+    }
+    let _ = encoder.long_distance_matching(true);
+    let _ = encoder.window_log(30);
+
+    encoder.write_all(MAGIC)?;
+
+    let mut file_list = Vec::new();
+    {
+        let mut tar_builder = Builder::new(&mut encoder);
+        for entry in &entries {
+            let full = entry.path();
+            let rel = full.strip_prefix(base).unwrap_or(full);
+            let rel_str = rel.to_string_lossy().replace('\\', "/");
+
+            let metadata = match std::fs::metadata(full) {
+                Ok(m) => m,
+                Err(_) => continue,
+            };
+            let size = metadata.len();
+
+            let mut header = Header::new_gnu();
+            header.set_size(size);
+            header.set_mode(0o644);
+            header.set_cksum();
+
+            let file = match File::open(full) {
+                Ok(f) => f,
+                Err(_) => continue,
+            };
+            let buf_reader = std::io::BufReader::with_capacity(
+                (size as usize).min(4 * 1024 * 1024).max(8192),
+                file,
+            );
+
+            tar_builder.append_data(&mut header, &rel_str, buf_reader)
+                .map_err(|e| anyhow::anyhow!("tar append {}: {}", rel_str, e))?;
+
+            file_list.push(serde_json::json!({"name": rel_str, "size": size}));
+        }
+        tar_builder.finish().map_err(|e| anyhow::anyhow!("tar finish: {}", e))?;
+    }
+
+    encoder.finish().map_err(|e| anyhow::anyhow!("zstd finish: {}", e))?;
+
+    Ok(file_list)
+}
+
+fn write_png_from_zst(
+    zst_path: &Path,
+    output_path: &Path,
+    name: Option<&str>,
+    file_list: Option<&str>,
+    passphrase: Option<&str>,
+    _encrypt_type: Option<&str>,
+) -> anyhow::Result<()> {
+    let zst_size = std::fs::metadata(zst_path)?.len() as usize;
+
+    let mut encryptor = match passphrase {
+        Some(pass) if !pass.is_empty() => Some(crate::crypto::StreamingEncryptor::new(pass)?),
+        _ => None,
+    };
+
+    let enc_header_len = encryptor.as_ref().map(|e| e.header_len()).unwrap_or(1);
+    let hmac_trailer_len: usize = if encryptor.is_some() { 32 } else { 0 };
+
+    let encrypted_payload_len = enc_header_len + zst_size + hmac_trailer_len;
+
+    let version = 1u8;
+    let name_bytes = name.map(|n| n.as_bytes()).unwrap_or(&[]);
+    let name_len = name_bytes.len().min(255) as u8;
+    let payload_len_bytes = (encrypted_payload_len as u32).to_be_bytes();
+
+    let mut meta_header = Vec::with_capacity(1 + 1 + name_len as usize + 4);
+    meta_header.push(version);
+    meta_header.push(name_len);
+    if name_len > 0 {
+        meta_header.extend_from_slice(&name_bytes[..name_len as usize]);
+    }
+    meta_header.extend_from_slice(&payload_len_bytes);
+
+    let meta_header_len = meta_header.len();
+
+    let file_list_chunk = file_list.map(|fl| {
+        let json_bytes = fl.as_bytes();
+        let mut chunk = Vec::with_capacity(4 + 4 + json_bytes.len());
+        chunk.extend_from_slice(b"rXFL");
+        chunk.extend_from_slice(&(json_bytes.len() as u32).to_be_bytes());
+        chunk.extend_from_slice(json_bytes);
+        chunk
+    });
+    let file_list_inline_len = file_list_chunk.as_ref().map(|c| c.len()).unwrap_or(0);
+
+    let total_meta_pixel_len = meta_header_len + encrypted_payload_len + file_list_inline_len;
+    let raw_payload_len = PIXEL_MAGIC.len() + total_meta_pixel_len;
+    let padding_needed = (3 - (raw_payload_len % 3)) % 3;
+    let padded_len = raw_payload_len + padding_needed;
+
+    let marker_start_len = 12;
+    let data_with_markers_len = marker_start_len + padded_len;
+    let data_pixels = (data_with_markers_len + 2) / 3;
+    let end_marker_pixels = 3;
+    let total_pixels = data_pixels + end_marker_pixels;
+
+    let side = (total_pixels as f64).sqrt().ceil() as usize;
+    let side = side.max(end_marker_pixels);
+    let width = side;
+    let height = side;
+    let row_bytes = width * 3;
+    let total_data_bytes = width * height * 3;
+    let marker_end_pos = (height - 1) * width * 3 + (width - end_marker_pixels) * 3;
+
+    let enc_header_bytes = if let Some(ref enc) = encryptor {
+        enc.header.clone()
+    } else {
+        vec![0x00]
+    };
+
+    let header_bytes = build_header_bytes(&meta_header, &enc_header_bytes);
+
+    let stride = row_bytes + 1;
+    let scanlines_total = height * stride;
+
+    const MAX_BLOCK: usize = 65535;
+    let num_blocks = (scanlines_total + MAX_BLOCK - 1) / MAX_BLOCK;
+    let idat_len = 2 + num_blocks * 5 + scanlines_total + 4;
+
+    let out_file = File::create(output_path)?;
+    let mut w = BufWriter::with_capacity(16 * 1024 * 1024, out_file);
+
+    w.write_all(PNG_HEADER)?;
+
+    let mut ihdr = [0u8; 13];
+    ihdr[0..4].copy_from_slice(&(width as u32).to_be_bytes());
+    ihdr[4..8].copy_from_slice(&(height as u32).to_be_bytes());
+    ihdr[8] = 8;
+    ihdr[9] = 2;
+    write_chunk_hdr(&mut w, b"IHDR", &ihdr)?;
+
+    let mut zst_file = File::open(zst_path)?;
+    let mut zst_reader = std::io::BufReader::with_capacity(16 * 1024 * 1024, &mut zst_file);
+
+    write_idat_streaming(
+        &mut w,
+        &header_bytes,
+        &mut zst_reader,
+        zst_size,
+        file_list_chunk.as_deref(),
+        &mut encryptor,
+        hmac_trailer_len,
+        height,
+        row_bytes,
+        marker_end_pos,
+        idat_len,
+        total_data_bytes,
+    )?;
+
+    if let Some(fl) = file_list {
+        write_chunk_hdr(&mut w, b"rXFL", fl.as_bytes())?;
+    }
+    write_chunk_hdr(&mut w, b"IEND", &[])?;
+    w.flush()?;
+
+    Ok(())
+}
+
+fn build_header_bytes(meta_header: &[u8], enc_header: &[u8]) -> Vec<u8> {
+    let mut header = Vec::with_capacity(12 + PIXEL_MAGIC.len() + meta_header.len() + enc_header.len());
+    for m in &MARKER_START {
+        header.push(m.0); header.push(m.1); header.push(m.2);
+    }
+    header.push(MARKER_ZSTD.0); header.push(MARKER_ZSTD.1); header.push(MARKER_ZSTD.2);
+    header.extend_from_slice(PIXEL_MAGIC);
+    header.extend_from_slice(meta_header);
+    header.extend_from_slice(enc_header);
+    header
+}
+
+fn write_idat_streaming<W: Write, R: Read>(
+    w: &mut W,
+    header_bytes: &[u8],
+    zst_reader: &mut R,
+    zst_size: usize,
+    file_list_chunk: Option<&[u8]>,
+    encryptor: &mut Option<crate::crypto::StreamingEncryptor>,
+    hmac_trailer_len: usize,
+    height: usize,
+    row_bytes: usize,
+    marker_end_pos: usize,
+    idat_len: usize,
+    total_data_bytes: usize,
+) -> anyhow::Result<()> {
+    w.write_all(&(idat_len as u32).to_be_bytes())?;
+    w.write_all(b"IDAT")?;
+
+    let mut crc = crc32fast::Hasher::new();
+    crc.update(b"IDAT");
+
+    let stride = row_bytes + 1;
+    let scanlines_total = height * stride;
+
+    let zlib = [0x78u8, 0x01];
+    w.write_all(&zlib)?;
+    crc.update(&zlib);
+
+    let fl_chunk_data = file_list_chunk.unwrap_or(&[]);
+    let payload_total = header_bytes.len() + zst_size + hmac_trailer_len + fl_chunk_data.len();
+    let padding_after = total_data_bytes - payload_total.min(total_data_bytes);
+
+    let marker_end_bytes = build_marker_end_bytes();
+
+    let mut flat_pos: usize = 0;
+    let mut scanline_pos: usize = 0;
+    let mut deflate_block_remaining: usize = 0;
+
+    let mut header_pos: usize = 0;
+    let mut zst_remaining = zst_size;
+    let mut hmac_pos: usize = 0;
+    let mut hmac_written = hmac_trailer_len == 0;
+    let mut hmac_finalized: Option<[u8; 32]> = None;
+    let mut fl_pos: usize = 0;
+    let mut zero_remaining = padding_after;
+
+    let mut adler_a: u32 = 1;
+    let mut adler_b: u32 = 0;
+
+    let buf_size = 1024 * 1024;
+    let mut transfer_buf = vec![0u8; buf_size];
+
+    for _row in 0..height {
+        if deflate_block_remaining == 0 {
+            let remaining_scanlines = scanlines_total - scanline_pos;
+            let block_size = remaining_scanlines.min(65535);
+            let is_last = scanline_pos + block_size >= scanlines_total;
+            let header = [
+                if is_last { 0x01 } else { 0x00 },
+                block_size as u8,
+                (block_size >> 8) as u8,
+                !block_size as u8,
+                (!(block_size >> 8)) as u8,
+            ];
+            w.write_all(&header)?;
+            crc.update(&header);
+            deflate_block_remaining = block_size;
+        }
+
+        let filter_byte = [0u8];
+        w.write_all(&filter_byte)?;
+        crc.update(&filter_byte);
+        adler_a = (adler_a + 0) % 65521;
+        adler_b = (adler_b + adler_a) % 65521;
+        scanline_pos += 1;
+        deflate_block_remaining -= 1;
+
+        let mut cols_written = 0;
+        while cols_written < row_bytes {
+            if deflate_block_remaining == 0 {
+                let remaining_scanlines = scanlines_total - scanline_pos;
+                let block_size = remaining_scanlines.min(65535);
+                let is_last = scanline_pos + block_size >= scanlines_total;
+                let header = [
+                    if is_last { 0x01 } else { 0x00 },
+                    block_size as u8,
+                    (block_size >> 8) as u8,
+                    !block_size as u8,
+                    (!(block_size >> 8)) as u8,
+                ];
+                w.write_all(&header)?;
+                crc.update(&header);
+                deflate_block_remaining = block_size;
+            }
+
+            let can_write = (row_bytes - cols_written).min(deflate_block_remaining);
+
+            let mut chunk_written = 0;
+            while chunk_written < can_write {
+                let need = can_write - chunk_written;
+
+                let is_marker_end_region = flat_pos >= marker_end_pos && flat_pos < marker_end_pos + 9;
+
+                if is_marker_end_region {
+                    let me_offset = flat_pos - marker_end_pos;
+                    let me_remaining = 9 - me_offset;
+                    let take = need.min(me_remaining);
+                    let slice = &marker_end_bytes[me_offset..me_offset + take];
+                    w.write_all(slice)?;
+                    crc.update(slice);
+                    for &b in slice {
+                        adler_a = (adler_a + b as u32) % 65521;
+                        adler_b = (adler_b + adler_a) % 65521;
+                    }
+                    flat_pos += take;
+                    chunk_written += take;
+                    scanline_pos += take;
+                    deflate_block_remaining -= take;
+                    cols_written += take;
+                    continue;
+                }
+
+                if header_pos < header_bytes.len() {
+                    let avail = header_bytes.len() - header_pos;
+                    let take = need.min(avail);
+                    let slice = &header_bytes[header_pos..header_pos + take];
+                    w.write_all(slice)?;
+                    crc.update(slice);
+                    for &b in slice {
+                        adler_a = (adler_a + b as u32) % 65521;
+                        adler_b = (adler_b + adler_a) % 65521;
+                    }
+                    header_pos += take;
+                    flat_pos += take;
+                    chunk_written += take;
+                    scanline_pos += take;
+                    deflate_block_remaining -= take;
+                    cols_written += take;
+                } else if zst_remaining > 0 {
+                    let take = need.min(zst_remaining).min(buf_size);
+                    let got = zst_reader.read(&mut transfer_buf[..take])
+                        .map_err(|e| anyhow::anyhow!("read zst: {}", e))?;
+                    if got == 0 { break; }
+                    if let Some(ref mut enc) = encryptor {
+                        enc.encrypt_chunk(&mut transfer_buf[..got]);
+                    }
+                    w.write_all(&transfer_buf[..got])?;
+                    crc.update(&transfer_buf[..got]);
+                    for &b in &transfer_buf[..got] {
+                        adler_a = (adler_a + b as u32) % 65521;
+                        adler_b = (adler_b + adler_a) % 65521;
+                    }
+                    zst_remaining -= got;
+                    flat_pos += got;
+                    chunk_written += got;
+                    scanline_pos += got;
+                    deflate_block_remaining -= got;
+                    cols_written += got;
+                } else if !hmac_written {
+                    if hmac_finalized.is_none() {
+                        if let Some(enc) = encryptor.take() {
+                            hmac_finalized = Some(enc.finalize_hmac());
+                        }
+                    }
+                    if let Some(ref hmac_bytes) = hmac_finalized {
+                        let avail = hmac_trailer_len - hmac_pos;
+                        let take = need.min(avail);
+                        let slice = &hmac_bytes[hmac_pos..hmac_pos + take];
+                        w.write_all(slice)?;
+                        crc.update(slice);
+                        for &b in slice {
+                            adler_a = (adler_a + b as u32) % 65521;
+                            adler_b = (adler_b + adler_a) % 65521;
+                        }
+                        hmac_pos += take;
+                        flat_pos += take;
+                        chunk_written += take;
+                        scanline_pos += take;
+                        deflate_block_remaining -= take;
+                        cols_written += take;
+                        if hmac_pos >= hmac_trailer_len {
+                            hmac_written = true;
+                        }
+                    } else {
+                        hmac_written = true;
+                    }
+                } else if fl_pos < fl_chunk_data.len() {
+                    let avail = fl_chunk_data.len() - fl_pos;
+                    let take = need.min(avail);
+                    let slice = &fl_chunk_data[fl_pos..fl_pos + take];
+                    w.write_all(slice)?;
+                    crc.update(slice);
+                    for &b in slice {
+                        adler_a = (adler_a + b as u32) % 65521;
+                        adler_b = (adler_b + adler_a) % 65521;
+                    }
+                    fl_pos += take;
+                    flat_pos += take;
+                    chunk_written += take;
+                    scanline_pos += take;
+                    deflate_block_remaining -= take;
+                    cols_written += take;
+                } else {
+                    let take = need.min(zero_remaining).min(buf_size);
+                    if take == 0 { break; }
+                    let zeros = vec![0u8; take];
+                    w.write_all(&zeros)?;
+                    crc.update(&zeros);
+                    for _ in 0..take {
+                        adler_b = (adler_b + adler_a) % 65521;
+                    }
+                    zero_remaining -= take;
+                    flat_pos += take;
+                    chunk_written += take;
+                    scanline_pos += take;
+                    deflate_block_remaining -= take;
+                    cols_written += take;
+                }
+            }
+        }
+    }
+
+    let adler = (adler_b << 16) | adler_a;
+    let adler_bytes = adler.to_be_bytes();
+    w.write_all(&adler_bytes)?;
+    crc.update(&adler_bytes);
+
+    w.write_all(&crc.finalize().to_be_bytes())?;
+    Ok(())
+}
+
+fn build_marker_end_bytes() -> [u8; 9] {
+    let mut buf = [0u8; 9];
+    for (i, m) in MARKER_END.iter().enumerate() {
+        buf[i * 3] = m.0;
+        buf[i * 3 + 1] = m.1;
+        buf[i * 3 + 2] = m.2;
+    }
+    buf
+}
+
+fn write_chunk_hdr<W: Write>(w: &mut W, chunk_type: &[u8; 4], data: &[u8]) -> anyhow::Result<()> {
+    w.write_all(&(data.len() as u32).to_be_bytes())?;
+    w.write_all(chunk_type)?;
+    w.write_all(data)?;
+    let mut h = crc32fast::Hasher::new();
+    h.update(chunk_type);
+    h.update(data);
+    w.write_all(&h.finalize().to_be_bytes())?;
+    Ok(())
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.11.1",
+  "version": "1.12.0",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",