@ankhorage/expo-runtime 3.1.1 → 3.2.2

package/src/reader/validateEpubArchiveEntriesAsync.test.ts

@@ -0,0 +1,142 @@
+import type { Entry } from '@zip.js/zip.js';
+import {
+  ERR_OVERLAPPING_ENTRY,
+  TextReader,
+  Uint8ArrayReader,
+  Uint8ArrayWriter,
+  ZipReader,
+  ZipWriter,
+} from '@zip.js/zip.js';
+import { describe, expect, test } from 'bun:test';
+
+import { validateEpubArchiveEntriesAsync } from './validateEpubArchiveEntriesAsync';
+
+describe('validateEpubArchiveEntriesAsync archive budgets', () => {
+  test('accepts a bounded archive and preflights every file without extracting it', async () => {
+    const entries = await createArchiveEntries([
+      ['mimetype', 'application/epub+zip'],
+      ['META-INF/container.xml', '<container />'],
+    ]);
+
+    expect(validateEpubArchiveEntriesAsync(entries)).resolves.toBeUndefined();
+    expect(entries.every((entry) => entry.directory || entry.localDirectory)).toBe(true);
+  });
+
+  test('rejects excessive entry counts before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['mimetype', 'application/epub+zip']]);
+
+    expect(validateEpubArchiveEntriesAsync(Array<Entry>(10_001).fill(entry))).rejects.toThrow(
+      'exceeds the 10000-entry limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects an oversized entry before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.uncompressedSize = 64 * 1024 * 1024 + 1;
+    entry.compressedSize = entry.uncompressedSize;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow(
+      'exceeds the 67108864-byte uncompressed limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects excessive aggregate expansion before reading entry data', async () => {
+    const entries = await createArchiveEntries(
+      Array.from({ length: 9 }, (_, index) => [`chapter-${index}.xhtml`, '<p>Chapter</p>']),
+    );
+
+    for (const entry of entries) {
+      entry.uncompressedSize = 64 * 1024 * 1024;
+      entry.compressedSize = entry.uncompressedSize;
+    }
+
+    expect(validateEpubArchiveEntriesAsync(entries)).rejects.toThrow(
+      'exceeds the 536870912-byte aggregate uncompressed limit',
+    );
+    expect(entries.every((entry) => !entry.localDirectory)).toBe(true);
+  });
+
+  test('rejects suspicious compression ratios before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.uncompressedSize = 10_001;
+    entry.compressedSize = 100;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow(
+      'exceeds the 100:1 compression-ratio limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+});
+
+describe('validateEpubArchiveEntriesAsync archive structure', () => {
+  test('rejects invalid declared sizes before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.compressedSize = Number.NaN;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow('declares invalid sizes');
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects overlapping entry ranges during the no-extraction preflight', async () => {
+    const archive = await createArchive([
+      ['first.txt', 'same'],
+      ['other.txt', 'same'],
+    ]);
+    const centralDirectoryOffsets = findSignatureOffsets(archive, 0x02014b50);
+    const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+    const firstLocalHeaderOffset = archiveView.getUint32(centralDirectoryOffsets[0] + 42, true);
+    const firstCentralFilename = archive.slice(
+      centralDirectoryOffsets[0] + 46,
+      centralDirectoryOffsets[0] + 46 + 'first.txt'.length,
+    );
+    archive.set(firstCentralFilename, centralDirectoryOffsets[1] + 46);
+    archiveView.setUint32(centralDirectoryOffsets[1] + 42, firstLocalHeaderOffset, true);
+    const entries = await readArchiveEntries(archive, 'balanced');
+
+    expect(validateEpubArchiveEntriesAsync(entries)).rejects.toThrow(ERR_OVERLAPPING_ENTRY);
+  });
+});
+
+async function createArchive(
+  files: readonly (readonly [filename: string, content: string])[],
+): Promise<Uint8Array> {
+  const writer = new ZipWriter(new Uint8ArrayWriter());
+
+  for (const [filename, content] of files) {
+    await writer.add(filename, new TextReader(content));
+  }
+
+  return writer.close();
+}
+
+async function createArchiveEntries(
+  files: readonly (readonly [filename: string, content: string])[],
+): Promise<Entry[]> {
+  return readArchiveEntries(await createArchive(files));
+}
+
+function findSignatureOffsets(data: Uint8Array, signature: number): number[] {
+  const offsets: number[] = [];
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+  for (let offset = 0; offset <= data.byteLength - 4; offset += 1) {
+    if (view.getUint32(offset, true) === signature) {
+      offsets.push(offset);
+    }
+  }
+
+  return offsets;
+}
+
+async function readArchiveEntries(
+  data: Uint8Array,
+  strictness: 'balanced' | 'strict' = 'strict',
+): Promise<Entry[]> {
+  const reader = new ZipReader(new Uint8ArrayReader(data), {
+    strictness,
+  });
+
+  return reader.getEntries({ strictness });
+}

package/src/reader/validateEpubArchiveEntriesAsync.ts

@@ -0,0 +1,73 @@
+import type { Entry } from '@zip.js/zip.js';
+import { Uint8ArrayWriter } from '@zip.js/zip.js';
+
+const MAX_COMPRESSION_RATIO = 100;
+const MAX_ENTRY_COUNT = 10_000;
+const MAX_ENTRY_UNCOMPRESSED_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+
+export async function validateEpubArchiveEntriesAsync(
+  entries: readonly Entry[],
+  signal?: AbortSignal,
+): Promise<void> {
+  if (entries.length > MAX_ENTRY_COUNT) {
+    throw new Error(`EPUB archive exceeds the ${MAX_ENTRY_COUNT}-entry limit.`);
+  }
+
+  let totalUncompressedBytes = 0;
+
+  for (const entry of entries) {
+    validateDeclaredSizes(entry);
+
+    if (entry.directory) {
+      continue;
+    }
+
+    if (entry.uncompressedSize > MAX_ENTRY_UNCOMPRESSED_BYTES) {
+      throw new Error(
+        `EPUB archive entry "${entry.filename}" exceeds the ${MAX_ENTRY_UNCOMPRESSED_BYTES}-byte uncompressed limit.`,
+      );
+    }
+
+    if (
+      entry.uncompressedSize > 0 &&
+      (entry.compressedSize === 0 ||
+        entry.uncompressedSize > entry.compressedSize * MAX_COMPRESSION_RATIO)
+    ) {
+      throw new Error(
+        `EPUB archive entry "${entry.filename}" exceeds the ${MAX_COMPRESSION_RATIO}:1 compression-ratio limit.`,
+      );
+    }
+
+    if (totalUncompressedBytes > MAX_TOTAL_UNCOMPRESSED_BYTES - entry.uncompressedSize) {
+      throw new Error(
+        `EPUB archive exceeds the ${MAX_TOTAL_UNCOMPRESSED_BYTES}-byte aggregate uncompressed limit.`,
+      );
+    }
+
+    totalUncompressedBytes += entry.uncompressedSize;
+  }
+
+  for (const entry of entries) {
+    if (entry.directory) {
+      continue;
+    }
+
+    await entry.getData(new Uint8ArrayWriter(), {
+      checkOverlappingEntryOnly: true,
+      signal,
+      strictness: 'strict',
+    });
+  }
+}
+
+function validateDeclaredSizes(entry: Entry): void {
+  if (
+    !Number.isSafeInteger(entry.compressedSize) ||
+    entry.compressedSize < 0 ||
+    !Number.isSafeInteger(entry.uncompressedSize) ||
+    entry.uncompressedSize < 0
+  ) {
+    throw new Error(`EPUB archive entry "${entry.filename}" declares invalid sizes.`);
+  }
+}

package/src/resolveExpoRuntimePlan.test.ts

@@ -97,6 +97,42 @@ describe('resolveExpoRuntimePlan barcode capability', () => {
   });
 });
 
+describe('resolveExpoRuntimePlan ebook reader capability', () => {
+  test('selects the reader adapter and exact renderer packages without permissions', () => {
+    const plan = resolveExpoRuntimePlan(
+      withFirstScreenRequirements({ capabilities: [{ capability: 'ebookReader' }] }),
+    );
+
+    expect(plan.permissions).toEqual([]);
+    expect(plan.impliedPermissions).toEqual([]);
+    expect(plan.providers).toEqual([]);
+    expect(plan.nativeConfig.plugins).toEqual([]);
+    expect(plan.runtimeAdapters).toEqual(['ExpoReaderSurfaceAdapter']);
+    expect(plan.dependencies.map(({ name, version }) => ({ name, version }))).toEqual([
+      {
+        name: '@ankhorage/expo-runtime',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@ankhorage/expo-runtime'],
+      },
+      {
+        name: '@readium/navigator',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@readium/navigator'],
+      },
+      {
+        name: '@readium/shared',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@readium/shared'],
+      },
+      {
+        name: '@zip.js/zip.js',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@zip.js/zip.js'],
+      },
+      {
+        name: 'pdfjs-dist',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['pdfjs-dist'],
+      },
+    ]);
+  });
+});
+
 describe('resolveExpoRuntimePlan Expo 57 plugin coverage', () => {
   test('keeps microphone-only native configuration free of background audio behavior', () => {
     const plan = resolveExpoRuntimePlan(