@poe-platform/safe-bash 0.1.812 → 0.1.814

package/dist/spreadsheet-format-xls/biff-encrypted-properties.js

@@ -1,8 +1,9 @@
+import { BiffPropertyDescriptorIndex } from "./biff-property-index.js";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { stagePropertyBytes } from "./biff-property-bytes.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
 import { biffPropertyFormats } from "./biff-properties.js";
-import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
+import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.js";
 /** Admit the outer container and reject hidden plaintext property collisions
  * before asking for a password. POI emits an empty document-summary placeholder. */
 export async function encryptedBiffPropertyStream(streams, context, charge, propertySources) {
@@ -35,13 +36,14 @@ export async function encryptedBiffPropertyStream(streams, context, charge, prop
         if (key === "\u0005SUMMARYINFORMATION")
             invalidBiff("ambiguous plaintext document properties");
         charge(file.size);
-        for (const section of await readPropertySectionRanges(file, admit, charge)) {
+        for await (const section of readPropertySectionRanges(file, admit, charge, context)) {
             if (![biffPropertyFormats.document, biffPropertyFormats.custom].includes(section.guid))
                 invalidBiff("ambiguous plaintext document properties");
-            const values = await readPropertyValueRanges(file.slice(section.offset, section.end - section.offset), admit, charge);
-            for (const [id, value] of values)
-                if (id > 1 || id === 0 && (await value.u32(0)) !== 0 || id === 1 && (await value.u32(0)) !== 2)
-                    invalidBiff("ambiguous plaintext document properties");
+            await withPropertyValueRanges(file.slice(section.offset, section.end - section.offset), admit, charge, context, async (values) => {
+                for await (const [id, value] of values.entries())
+                    if (id > 1 || id === 0 && (await value.u32(0)) !== 0 || id === 1 && (await value.u32(0)) !== 2)
+                        invalidBiff("ambiguous plaintext document properties");
+            });
         }
     }
     if (!encrypted)
@@ -107,11 +109,25 @@ export function decryptBiffPropertyContainer(encrypted, keyStream, context, char
         const source = new Binary(encrypted), { offset, size } = propertyTableRange(decrypt(source.slice(0, 8), 0), source);
         const table = new Binary(decrypt(source.slice(offset, size), 0));
         const reader = readEncryptedPropertyDescriptors(source, offset, size, context, charge);
+        const descriptors = [], names = new Set();
         let step = reader.next();
-        while (!step.done)
-            step = reader.next(table.slice(step.value.at, step.value.size));
+        while (!step.done) {
+            if ("entry" in step.value) {
+                const entry = step.value.entry, name = entry.name.toUpperCase();
+                if (names.has(name))
+                    invalidBiff("duplicate or invalid encrypted property stream name");
+                names.add(name);
+                descriptors.push(entry);
+                step = reader.next(new Uint8Array());
+            }
+            else
+                step = reader.next(table.slice(step.value.at, step.value.size));
+        }
         table.bytes.fill(0);
-        const descriptors = step.value;
+        const ordered = [...descriptors].sort((a, b) => a.offset - b.offset);
+        for (let i = 1; i < ordered.length; i++)
+            if (ordered[i].offset < ordered[i - 1].offset + ordered[i - 1].size)
+                invalidBiff("overlapping encrypted property payloads");
         for (const entry of descriptors)
             result.set(entry.name, decrypt(source.slice(entry.offset, entry.size), entry.block));
         return result;
@@ -137,7 +153,6 @@ function* readEncryptedPropertyDescriptors(source, offset, size, context, charge
         throw new SsconvertError("resource-limit", "ssconvert encrypted BIFF property node limit exceeded");
     charge(count);
     let at = 4, textBytes = 0;
-    const descriptors = [], names = new Set();
     for (let i = 0; i < count; i++) {
         context.signal.throwIfAborted();
         const entry = new Binary(yield { at, size: 18 });
@@ -163,29 +178,32 @@ function* readEncryptedPropertyDescriptors(source, offset, size, context, charge
         catch {
             invalidBiff("invalid encrypted property stream name");
         }
-        if (name.includes("\0") || names.has(name.toUpperCase()))
+        if (name.includes("\0"))
             invalidBiff("duplicate or invalid encrypted property stream name");
-        names.add(name.toUpperCase());
         at += (nameLength + 1) * 2;
         source.check(start, length);
         if (start < 8 || start < offset + size && start + length > offset)
             invalidBiff("overlapping encrypted property ranges");
-        descriptors.push({ offset: start, size: length, block, name });
+        yield { entry: { offset: start, size: length, block, name } };
     }
     if (at !== size)
         invalidBiff("invalid encrypted property descriptor size");
     charge(count * Math.ceil(Math.log2(count + 1)));
-    const ordered = [...descriptors].sort((a, b) => a.offset - b.offset);
-    for (let i = 1; i < ordered.length; i++)
-        if (ordered[i].offset < ordered[i - 1].offset + ordered[i - 1].size)
-            invalidBiff("overlapping encrypted property payloads");
-    return descriptors;
 }
 /** Decrypt retained ciphertext and descriptor bytes directly into caller storage.
- * Parsed descriptors and names remain resident; plaintext transfers are bounded. */
+ * Parsed descriptors, duplicate names and overlap order use caller-backed indexes. */
 export async function decryptBiffPropertySources(encrypted, createCipher, context, charge) {
     const result = new Map(), owned = [];
     const input = propertyRange(encrypted, context);
+    let indexStorage;
+    let indexClosing;
+    const retireIndex = () => {
+        if (!indexStorage)
+            return indexClosing ?? Promise.resolve();
+        const storage = indexStorage;
+        indexStorage = undefined;
+        return indexClosing = storage.close();
+    };
     let closed = false;
     const check = () => { context.signal.throwIfAborted(); if (closed)
         throw new SsconvertError("invalid-request", "Encrypted BIFF property reader disposed"); };
@@ -193,7 +211,7 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         closed = true;
         for (const bytes of owned)
             bytes.fill(0);
-        const outcomes = await Promise.allSettled([...result.values()].map(source => source.close()));
+        const outcomes = await Promise.allSettled([...result.values()].map(source => source.close()).concat([retireIndex()]));
         result.clear();
         const errors = outcomes.filter((value) => value.status === "rejected").map(value => value.reason);
         if (errors.length)
@@ -242,10 +260,19 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         };
         const { offset, size } = propertyTableRange(await decrypt(0, 8), input);
         const table = await stagePropertyBytes({ length: size, chunks: () => chunks(offset, size, 0) }, context, context.limits.inputBytes);
-        const reader = readEncryptedPropertyDescriptors(input, offset, size, context, charge);
-        let step = reader.next();
+        let index;
         try {
+            indexStorage = context.createWorkingStorage();
+            check();
+            index = new BiffPropertyDescriptorIndex(indexStorage, check);
+            const reader = readEncryptedPropertyDescriptors(input, offset, size, context, charge);
+            let step = reader.next();
             while (!step.done) {
+                if ("entry" in step.value) {
+                    await index.add(step.value.entry);
+                    step = reader.next(new Uint8Array());
+                    continue;
+                }
                 const bytes = await table.read(step.value.at, step.value.size, { signal: context.signal });
                 try {
                     check();
@@ -267,12 +294,15 @@ export async function decryptBiffPropertySources(encrypted, createCipher, contex
         }
         await table.close();
         check();
-        const descriptors = step.value;
-        for (const entry of descriptors) {
+        await index.validate();
+        check();
+        for await (const entry of index.entries()) {
             const source = await stagePropertyBytes({ length: entry.size, chunks: () => chunks(entry.offset, entry.size, entry.block) }, context, context.limits.inputBytes);
             result.set(entry.name, source);
             check();
         }
+        await retireIndex();
+        check();
         return result;
     }
     catch (error) {

package/dist/spreadsheet-format-xls/biff-properties-merge.d.ts

@@ -1,4 +1,8 @@
-import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
+import { type CapabilityContext, type RangeSource } from "../spreadsheet-engine/contracts.js";
 import type { UnsupportedRecord, Workbook } from "../spreadsheet-ast/index.js";
 /** Rebuild offsets around original opaque spans. Never transcode their codepage. */
-export declare function mergeBiffProperties(book: Workbook, streams: Map<string, Uint8Array>, handled: Set<UnsupportedRecord>, context: CapabilityContext, charge: (amount: number) => void, allocate: (length: number) => Uint8Array): Promise<ReadonlySet<string>>;
+export declare function mergeBiffProperties(book: Workbook, streams: Map<string, Uint8Array | RangeSource>, handled: Set<UnsupportedRecord>, context: CapabilityContext, charge: (amount: number) => void, allocate: (length: number) => Uint8Array, staged?: {
+    sources: Map<string, BiffPropertySource>;
+    reserve: (length: number) => number;
+}): Promise<ReadonlySet<string>>;