feat: fix hardcoded frame & bug

Author: lenzarchive

package.json

@@ -1,6 +1,6 @@
 {
   "name": "logo-bin-tool",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Web-based extract and repack tool for Unisoc logo.bin firmware images",
   "main": "server.js",
   "scripts": {

public/js/app.js

@@ -190,34 +190,37 @@ async function downloadFrame(index) {
 }
 
 async function handleExtractAll() {
-  log("Extracting all frames as PNG...", "info");
-
-  for (const frame of frames) {
-    canvas.width = frame.width;
-    canvas.height = frame.height;
-    const ctx = canvas.getContext("2d");
-
-    const img = await new Promise((resolve) => {
-      const i = new Image();
-      i.onload = () => resolve(i);
-      i.src = frame.url;
+  log(`Extracting all ${frames.length} frames as PNG...`, "info");
+
+  const renderFrameToBlob = (frame) =>
+    new Promise((resolve, reject) => {
+      const offscreen = document.createElement("canvas");
+      offscreen.width = frame.width;
+      offscreen.height = frame.height;
+      const ctx = offscreen.getContext("2d");
+
+      const img = new Image();
+      img.onload = () => {
+        ctx.drawImage(img, 0, 0);
+        offscreen.toBlob((blob) => {
+          if (!blob) return reject(new Error(`Failed to render frame ${frame.index}`));
+          resolve(blob);
+        }, "image/png");
+      };
+      img.onerror = () => reject(new Error(`Failed to load frame ${frame.index}`));
+      img.src = frame.url;
     });
 
-    ctx.drawImage(img, 0, 0);
-
-    await new Promise((resolve) => {
-      canvas.toBlob((blob) => {
-        const a = document.createElement("a");
-        a.href = URL.createObjectURL(blob);
-        a.download = `frame_${frame.index}.png`;
-        a.click();
-        URL.revokeObjectURL(a.href);
-        log(`Extracted frame_${frame.index}.png`, "ok");
-        resolve();
-      }, "image/png");
-    });
+  const blobs = await Promise.all(frames.map(renderFrameToBlob));
 
-    await new Promise((r) => setTimeout(r, 250));
+  for (let i = 0; i < blobs.length; i++) {
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(blobs[i]);
+    a.download = `frame_${frames[i].index}.png`;
+    a.click();
+    URL.revokeObjectURL(a.href);
+    log(`Extracted frame_${frames[i].index}.png`, "ok");
+    if (i < blobs.length - 1) await new Promise((r) => setTimeout(r, 80));
   }
 }
 

public/js/bmp.js

@@ -1,8 +1,17 @@
 function imageToBmp(imageData, width, height, targetFileSize) {
   const rowSize = Math.ceil((width * 3) / 4) * 4;
   const pixelDataSize = rowSize * height;
-  const fileSize = targetFileSize || 54 + pixelDataSize;
+  const minFileSize = 54 + pixelDataSize;
 
+  if (targetFileSize && targetFileSize < minFileSize) {
+    throw new Error(
+      `targetFileSize (${targetFileSize}) is smaller than the minimum required ` +
+      `BMP size (${minFileSize}) for a ${width}×${height} 24bpp image. ` +
+      `The original logo.bin may be corrupt or from an unsupported variant.`
+    );
+  }
+
+  const fileSize = targetFileSize || minFileSize;
   const buffer = new ArrayBuffer(fileSize);
   const bytes = new Uint8Array(buffer);
   const view = new DataView(buffer);

public/js/parser.js

@@ -1,5 +1,10 @@
-const HEADER_SIZE = 44;
 const GZ_MAGIC = [0x47, 0x5a];
+const SIZES_OFFSET = 24;
+const SIZE_ENTRY = 4;
+
+function computeHeaderSize(frameCount) {
+  return SIZES_OFFSET + frameCount * SIZE_ENTRY;
+}
 
 function validateMagic(bytes) {
   return bytes[0] === GZ_MAGIC[0] && bytes[1] === GZ_MAGIC[1];
@@ -8,7 +13,7 @@ function validateMagic(bytes) {
 function readSizes(view, count) {
   const sizes = [];
   for (let i = 0; i < count; i++) {
-    sizes.push(view.getUint32(24 + i * 4, true));
+    sizes.push(view.getUint32(SIZES_OFFSET + i * SIZE_ENTRY, true));
   }
   return sizes;
 }
@@ -17,9 +22,18 @@ async function parseLogoBin(arrayBuffer) {
   const bytes = new Uint8Array(arrayBuffer);
   const view = new DataView(arrayBuffer);
 
-  if (!validateMagic(bytes)) throw new Error("Invalid file: expected GZ magic bytes");
+  if (!validateMagic(bytes)) throw new Error("Invalid file: expected GZ magic bytes (0x47 0x5A)");
 
   const frameCount = view.getUint32(2, true);
+  if (frameCount === 0 || frameCount > 64) {
+    throw new Error(`Unexpected frame count: ${frameCount}. File may be corrupt or unsupported.`);
+  }
+
+  const HEADER_SIZE = computeHeaderSize(frameCount);
+  if (arrayBuffer.byteLength < HEADER_SIZE) {
+    throw new Error("File too small to contain a valid header.");
+  }
+
   const sizes = readSizes(view, frameCount);
 
   let offset = HEADER_SIZE;
@@ -56,6 +70,7 @@ async function buildLogoBin(frames) {
 
   const sizes = recompressed.map((c) => c.length);
   const totalPayload = sizes.reduce((a, b) => a + b, 0);
+  const HEADER_SIZE = computeHeaderSize(frames.length);
   const output = new Uint8Array(HEADER_SIZE + totalPayload);
   const outView = new DataView(output.buffer);
 
@@ -64,7 +79,7 @@ async function buildLogoBin(frames) {
   outView.setUint32(2, frames.length, true);
 
   for (let i = 0; i < frames.length; i++) {
-    outView.setUint32(24 + i * 4, sizes[i], true);
+    outView.setUint32(SIZES_OFFSET + i * SIZE_ENTRY, sizes[i], true);
   }
 
   let writeOffset = HEADER_SIZE;

src/routes/api.js

@@ -9,7 +9,40 @@ const upload = multer({
   limits: { fileSize: 50 * 1024 * 1024 },
 });
 
-router.post("/extract", upload.single("bin"), async (req, res) => {
+const rateLimitMap = new Map();
+const RATE_LIMIT = 30;
+const RATE_WINDOW = 60 * 1000;
+
+function rateLimit(req, res, next) {
+  const ip = req.ip || req.socket.remoteAddress || "unknown";
+  const now = Date.now();
+  const entry = rateLimitMap.get(ip);
+
+  if (!entry || now - entry.windowStart > RATE_WINDOW) {
+    rateLimitMap.set(ip, { count: 1, windowStart: now });
+    return next();
+  }
+
+  entry.count++;
+  if (entry.count > RATE_LIMIT) {
+    const retryAfter = Math.ceil((RATE_WINDOW - (now - entry.windowStart)) / 1000);
+    res.set("Retry-After", retryAfter);
+    return res.status(429).json({
+      error: `Too many requests. Try again in ${retryAfter}s.`,
+    });
+  }
+
+  next();
+}
+
+setInterval(() => {
+  const now = Date.now();
+  for (const [ip, entry] of rateLimitMap.entries()) {
+    if (now - entry.windowStart > RATE_WINDOW) rateLimitMap.delete(ip);
+  }
+}, RATE_WINDOW);
+
+router.post("/extract", rateLimit, upload.single("bin"), async (req, res) => {
   try {
     if (!req.file) return res.status(400).json({ error: "No file uploaded" });
 
@@ -29,7 +62,7 @@ router.post("/extract", upload.single("bin"), async (req, res) => {
   }
 });
 
-router.post("/frame/:index", upload.single("bin"), async (req, res) => {
+router.post("/frame/:index", rateLimit, upload.single("bin"), async (req, res) => {
   try {
     if (!req.file) return res.status(400).json({ error: "No file uploaded" });
 
@@ -50,16 +83,15 @@ router.post("/frame/:index", upload.single("bin"), async (req, res) => {
 
 router.post(
   "/replace",
+  rateLimit,
   upload.fields([{ name: "bin" }, { name: "image" }]),
   async (req, res) => {
     try {
       const binFile = req.files?.["bin"]?.[0];
       const imageFile = req.files?.["image"]?.[0];
 
       if (!binFile || !imageFile) {
-        return res
-          .status(400)
-          .json({ error: "Both bin and image files are required" });
+        return res.status(400).json({ error: "Both bin and image files are required" });
       }
 
       const frameIndex = parseInt(req.body.frameIndex, 10);
@@ -79,6 +111,15 @@ router.post(
 
       const rowSize = Math.ceil((width * 3) / 4) * 4;
       const pixelDataSize = rowSize * height;
+      const minSize = 54 + pixelDataSize;
+
+      if (decompressedSize < minSize) {
+        return res.status(400).json({
+          error: `Frame ${frameIndex} decompressedSize (${decompressedSize}) is smaller than ` +
+                 `minimum BMP size (${minSize}) for ${width}×${height}. File may be corrupt.`,
+        });
+      }
+
       const bmpBuffer = Buffer.alloc(decompressedSize);
 
       bmpBuffer[0] = 0x42;

src/services/logoBin.js

@@ -5,8 +5,13 @@ const { parseBmpHeader } = require("../utils/bmp");
 const inflate = promisify(zlib.gunzip);
 const deflate = promisify(zlib.gzip);
 
-const HEADER_SIZE = 44;
 const MAGIC = Buffer.from([0x47, 0x5a]);
+const SIZES_OFFSET = 24;
+const SIZE_ENTRY = 4;
+
+function computeHeaderSize(frameCount) {
+  return SIZES_OFFSET + frameCount * SIZE_ENTRY;
+}
 
 function validateMagic(buffer) {
   return buffer[0] === MAGIC[0] && buffer[1] === MAGIC[1];
@@ -15,17 +20,26 @@ function validateMagic(buffer) {
 function readFrameSizes(buffer, count) {
   const sizes = [];
   for (let i = 0; i < count; i++) {
-    sizes.push(buffer.readUInt32LE(24 + i * 4));
+    sizes.push(buffer.readUInt32LE(SIZES_OFFSET + i * SIZE_ENTRY));
   }
   return sizes;
 }
 
 async function extractFrames(buffer) {
   if (!validateMagic(buffer)) {
-    throw new Error("Invalid logo.bin: expected GZ magic");
+    throw new Error("Invalid logo.bin: expected GZ magic bytes (0x47 0x5A)");
   }
 
   const frameCount = buffer.readUInt32LE(2);
+  if (frameCount === 0 || frameCount > 64) {
+    throw new Error(`Unexpected frame count: ${frameCount}. File may be corrupt or unsupported.`);
+  }
+
+  const HEADER_SIZE = computeHeaderSize(frameCount);
+  if (buffer.length < HEADER_SIZE) {
+    throw new Error("File too small to contain a valid header.");
+  }
+
   const compressedSizes = readFrameSizes(buffer, frameCount);
 
   let offset = HEADER_SIZE;
@@ -54,10 +68,11 @@ async function extractFrames(buffer) {
 
 async function repackFrames(originalBuffer, frameIndex, newBmpBuffer) {
   if (!validateMagic(originalBuffer)) {
-    throw new Error("Invalid logo.bin: expected GZ magic");
+    throw new Error("Invalid logo.bin: expected GZ magic bytes (0x47 0x5A)");
   }
 
   const frameCount = originalBuffer.readUInt32LE(2);
+  const HEADER_SIZE = computeHeaderSize(frameCount);
   const compressedSizes = readFrameSizes(originalBuffer, frameCount);
 
   let offset = HEADER_SIZE;
@@ -79,7 +94,7 @@ async function repackFrames(originalBuffer, frameIndex, newBmpBuffer) {
   output.writeUInt32LE(frameCount, 2);
 
   for (let i = 0; i < frameCount; i++) {
-    output.writeUInt32LE(newSizes[i], 24 + i * 4);
+    output.writeUInt32LE(newSizes[i], SIZES_OFFSET + i * SIZE_ENTRY);
   }
 
   let writeOffset = HEADER_SIZE;