roxify 1.9.4 → 1.9.6

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.9.4"
+version = "1.9.6"
 edition = "2021"
 publish = false
 

package/dist/utils/inspection.js

@@ -126,6 +126,13 @@ export async function listFilesInPng(pngBuf, opts = {}) {
         }
     }
     catch (e) { }
+    try {
+        const json = native.extractFileListFromPixels(pngBuf);
+        if (json) {
+            return parseFileList(JSON.parse(json));
+        }
+    }
+    catch (e) { }
     return null;
 }
 export async function hasPassphraseInPng(pngBuf) {

package/native/image_utils.rs

@@ -1,14 +1,21 @@
-use image::{ImageFormat, DynamicImage};
+use image::{ImageFormat, DynamicImage, ImageReader};
 use std::io::Cursor;
 
+fn load_no_limits(input: &[u8]) -> Result<DynamicImage, String> {
+    let mut reader = ImageReader::new(Cursor::new(input))
+        .with_guessed_format()
+        .map_err(|e| format!("Failed to guess format: {}", e))?;
+    reader.no_limits();
+    reader.decode().map_err(|e| format!("Failed to load image: {}", e))
+}
+
 pub fn sharp_resize(
     input: &[u8],
     width: u32,
     height: u32,
     kernel: &str,
 ) -> Result<Vec<u8>, String> {
-    let img = image::load_from_memory(input)
-        .map_err(|e| format!("Failed to load image: {}", e))?;
+    let img = load_no_limits(input)?;
 
     let filter = match kernel {
         "nearest" => image::imageops::FilterType::Nearest,
@@ -28,8 +35,7 @@ pub fn sharp_resize(
 }
 
 pub fn sharp_raw_pixels(input: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
-    let img = image::load_from_memory(input)
-        .map_err(|e| format!("Failed to load image: {}", e))?;
+    let img = load_no_limits(input)?;
 
     let rgb = img.to_rgb8();
     let width = rgb.width();
@@ -40,8 +46,7 @@ pub fn sharp_raw_pixels(input: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
 }
 
 pub fn sharp_metadata(input: &[u8]) -> Result<(u32, u32, String), String> {
-    let img = image::load_from_memory(input)
-        .map_err(|e| format!("Failed to load image: {}", e))?;
+    let img = load_no_limits(input)?;
 
     let width = img.width();
     let height = img.height();

package/native/lib.rs

@@ -389,6 +389,13 @@ pub fn crop_and_reconstitute(png_buffer: Buffer) -> Result<Vec<u8>> {
         .map_err(|e| Error::from_reason(e))
 }
 
+#[cfg(not(test))]
+#[napi]
+pub fn extract_file_list_from_pixels(png_buffer: Buffer) -> Result<String> {
+    png_utils::extract_file_list_from_pixels(&png_buffer)
+        .map_err(|e| Error::from_reason(e))
+}
+
 // ─── WAV container NAPI exports ──────────────────────────────────────────────
 
 #[cfg(not(test))]

package/native/png_utils.rs

@@ -1,5 +1,6 @@
 use bytemuck::{Pod, Zeroable};
-use std::io::{Read, Seek, SeekFrom};
+use image::ImageReader;
+use std::io::{Cursor, Read, Seek, SeekFrom};
 
 #[repr(C)]
 #[derive(Clone, Copy, Pod, Zeroable)]
@@ -176,7 +177,11 @@ fn find_pixel_header(raw: &[u8]) -> Result<usize, String> {
 }
 
 fn decode_to_rgb(png_data: &[u8]) -> Result<Vec<u8>, String> {
-    let img = image::load_from_memory(png_data).map_err(|e| format!("image load error: {}", e))?;
+    let mut reader = ImageReader::new(Cursor::new(png_data))
+        .with_guessed_format()
+        .map_err(|e| format!("format guess error: {}", e))?;
+    reader.no_limits();
+    let img = reader.decode().map_err(|e| format!("image decode error: {}", e))?;
     Ok(img.to_rgb8().into_raw())
 }
 
@@ -184,8 +189,13 @@ pub fn extract_name_from_png(png_data: &[u8]) -> Option<String> {
     if let Some(name) = extract_name_direct(png_data) {
         return Some(name);
     }
-    let reconst = crate::reconstitution::crop_and_reconstitute(png_data).ok()?;
-    extract_name_direct(&reconst)
+    if let Ok(reconst) = crate::reconstitution::crop_and_reconstitute(png_data) {
+        if let Some(name) = extract_name_direct(&reconst) {
+            return Some(name);
+        }
+    }
+    let unstretched = crate::reconstitution::unstretch_nn(png_data).ok()?;
+    extract_name_direct(&unstretched)
 }
 
 fn extract_name_direct(png_data: &[u8]) -> Option<String> {
@@ -224,8 +234,13 @@ pub fn extract_file_list_from_pixels(png_data: &[u8]) -> Result<String, String>
     if let Ok(result) = extract_file_list_direct(png_data) {
         return Ok(result);
     }
-    let reconst = crate::reconstitution::crop_and_reconstitute(png_data)?;
-    extract_file_list_direct(&reconst)
+    if let Ok(reconst) = crate::reconstitution::crop_and_reconstitute(png_data) {
+        if let Ok(result) = extract_file_list_direct(&reconst) {
+            return Ok(result);
+        }
+    }
+    let unstretched = crate::reconstitution::unstretch_nn(png_data)?;
+    extract_file_list_direct(&unstretched)
 }
 
 fn extract_file_list_direct(png_data: &[u8]) -> Result<String, String> {

package/native/reconstitution.rs

@@ -1,5 +1,14 @@
-use image::{Rgba, RgbaImage};
+use image::{Rgba, RgbaImage, DynamicImage, ImageReader};
 use std::cmp::min;
+use std::io::Cursor;
+
+fn load_image_no_limits(data: &[u8]) -> Result<DynamicImage, String> {
+    let mut reader = ImageReader::new(Cursor::new(data))
+        .with_guessed_format()
+        .map_err(|e| format!("format guess error: {}", e))?;
+    reader.no_limits();
+    reader.decode().map_err(|e| format!("image decode error: {}", e))
+}
 
 fn color_dist(a: [u8; 4], b: [u8; 4]) -> i32 {
     (a[0] as i32 - b[0] as i32).abs() +
@@ -77,7 +86,7 @@ fn intra_block_transitions_v(
 }
 
 pub fn crop_and_reconstitute(png_data: &[u8]) -> Result<Vec<u8>, String> {
-    let img = image::load_from_memory(png_data).unwrap();
+    let img = load_image_no_limits(png_data)?;
     let rgba = img.to_rgba8();
     let width = rgba.width();
     let height = rgba.height();
@@ -411,13 +420,13 @@ pub fn crop_and_reconstitute(png_data: &[u8]) -> Result<Vec<u8>, String> {
     }
 
     let mut output = Vec::new();
-    out.write_to(&mut std::io::Cursor::new(&mut output), image::ImageFormat::Png).unwrap();
+    out.write_to(&mut std::io::Cursor::new(&mut output), image::ImageFormat::Png)
+        .map_err(|e| format!("PNG write error: {}", e))?;
     Ok(output)
 }
 
 pub fn unstretch_nn(png_data: &[u8]) -> Result<Vec<u8>, String> {
-    let img = image::load_from_memory(png_data)
-        .map_err(|e| format!("image load error: {}", e))?;
+    let img = load_image_no_limits(png_data)?;
     let rgba = img.to_rgba8();
     let width = rgba.width() as usize;
     let height = rgba.height() as usize;

package/package.json

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