Extract the runtime corpus inside PHP

chubes4 · chubes4 · commit fac127a313f1 · 2026-07-19T02:18:38.000-04:00
diff --git a/packages/runtime-cloudflare/src/wordpress-runtime-artifact.ts b/packages/runtime-cloudflare/src/wordpress-runtime-artifact.ts
@@ -1,4 +1,3 @@
-import { decodeZip } from "@php-wasm/stream-compression"
 import { isWordPressRuntimeFile } from "./wordpress-runtime-corpus.js"
 
 export const WORDPRESS_RUNTIME_ARTIFACT_SCHEMA = "wp-codebox/wordpress-runtime-artifact/v1"
@@ -16,10 +15,18 @@ export interface WordPressRuntimeArtifactManifest {
 }
 
 export interface RuntimeMemfs {
-  mkdir(path: string): void
   writeFile(path: string, bytes: Uint8Array): void
+  run(request: { code: string }): Promise<{ text: string }>
 }
 
+const WORDPRESS_RUNTIME_ARCHIVE_TEMP_PATH = "/tmp/wp-codebox-wordpress-runtime.zip"
+const REQUIRED_WORDPRESS_RUNTIME_FILES = [
+  "wordpress/index.php",
+  "wordpress/wp-load.php",
+  "wordpress/wp-includes/version.php",
+  "wordpress/wp-settings.php",
+]
+
 export function wordpressRuntimeArtifactKey(sha256: string): string {
   if (!/^[a-f0-9]{64}$/.test(sha256)) throw new Error("WordPress runtime artifact hash must be a SHA-256 digest.")
   return `runtime/wordpress/${sha256}.zip`
@@ -52,24 +59,71 @@ export async function materializeWordPressRuntimeArtifact(php: RuntimeMemfs, buc
   // The archive and expanded corpus caps leave most of the 128 MiB isolate for PHP-WASM and runtime overhead.
   const archiveBytes = new Uint8Array(await object.arrayBuffer())
   if (await sha256Hex(archiveBytes) !== manifest.archive.sha256) throw new Error("WordPress runtime artifact archive hash does not match its manifest.")
-  const expected = new Map(manifest.files.map((file) => [file.path, file]))
-  let materializedFiles = 0
-  let materializedBytes = 0
-  for await (const entry of decodeZip(new Blob([archiveBytes]).stream())) {
-    const file = expected.get(entry.name)
-    if (!file) throw new Error(`WordPress runtime artifact contains an unexpected file: ${entry.name}`)
-    const bytes = new Uint8Array(await entry.arrayBuffer())
-    if (bytes.byteLength !== file.size || await sha256Hex(bytes) !== file.sha256) throw new Error(`WordPress runtime artifact file validation failed: ${entry.name}`)
-    materializedBytes += bytes.byteLength
-    materializedFiles++
-    if (materializedFiles > WORDPRESS_RUNTIME_MAX_FILES || materializedBytes > WORDPRESS_RUNTIME_MAX_UNCOMPRESSED_BYTES) throw new Error("WordPress runtime artifact exceeds its materialization budget.")
-    const destination = `/${entry.name}`
-    php.mkdir(destination.slice(0, destination.lastIndexOf("/")))
-    php.writeFile(destination, bytes)
-    expected.delete(entry.name)
+
+  // The archive digest binds these bytes to the already path- and budget-checked manifest.
+  // Crossing into PHP once avoids per-file JS/WASM calls during cold boot.
+  php.writeFile(WORDPRESS_RUNTIME_ARCHIVE_TEMP_PATH, archiveBytes)
+  const output = (await php.run({ code: zipMaterializationCode(manifest) })).text.trim()
+  let evidence: unknown
+  try {
+    evidence = JSON.parse(output)
+  } catch {
+    throw new Error(`WordPress runtime artifact extraction did not return valid evidence: ${output}`)
   }
-  if (expected.size) throw new Error("WordPress runtime artifact is missing manifest files.")
-  return { materializedFiles, materializedBytes }
+  if (!isMaterializationEvidence(evidence, manifest)) throw new Error("WordPress runtime artifact extraction returned invalid evidence.")
+  return evidence
+}
+
+function zipMaterializationCode(manifest: WordPressRuntimeArtifactManifest): string {
+  const expected = Object.fromEntries(manifest.files.map((file) => [file.path, file.size]))
+  const expectedJson = JSON.stringify(expected).replace(/</g, "\\u003c")
+  const requiredJson = JSON.stringify(REQUIRED_WORDPRESS_RUNTIME_FILES)
+  return `<?php
+$archive_path = ${JSON.stringify(WORDPRESS_RUNTIME_ARCHIVE_TEMP_PATH)};
+$expected = json_decode(${JSON.stringify(expectedJson)}, true, 512, JSON_THROW_ON_ERROR);
+$required = json_decode(${JSON.stringify(requiredJson)}, true, 512, JSON_THROW_ON_ERROR);
+try {
+    if (!extension_loaded('zip') || !class_exists('ZipArchive')) {
+        throw new RuntimeException('WordPress runtime artifact extraction requires the PHP ZipArchive extension.');
+    }
+    $zip = new ZipArchive();
+    $opened = $zip->open($archive_path);
+    if (true !== $opened) {
+        throw new RuntimeException('WordPress runtime artifact ZIP could not be opened (ZipArchive status ' . $opened . ').');
+    }
+    try {
+        if ($zip->numFiles !== count($expected)) {
+            throw new RuntimeException('WordPress runtime artifact ZIP file count does not match its manifest.');
+        }
+        for ($index = 0; $index < $zip->numFiles; $index++) {
+            $name = $zip->getNameIndex($index);
+            $stat = $zip->statIndex($index);
+            if (!is_string($name) || !array_key_exists($name, $expected) || !is_array($stat) || !isset($stat['size']) || (int) $stat['size'] !== $expected[$name]) {
+                throw new RuntimeException('WordPress runtime artifact ZIP entries do not match its manifest.');
+            }
+        }
+        if (!$zip->extractTo('/', array_keys($expected))) {
+            throw new RuntimeException('WordPress runtime artifact ZIP extraction failed.');
+        }
+        foreach ($required as $path) {
+            if (!is_file('/' . $path)) {
+                throw new RuntimeException('WordPress runtime artifact is missing required file after extraction: ' . $path);
+            }
+        }
+        echo json_encode(array('materializedFiles' => count($expected), 'materializedBytes' => array_sum($expected)), JSON_THROW_ON_ERROR);
+    } finally {
+        $zip->close();
+    }
+} finally {
+    @unlink($archive_path);
+}`
+}
+
+function isMaterializationEvidence(value: unknown, manifest: WordPressRuntimeArtifactManifest): value is { materializedFiles: number; materializedBytes: number } {
+  if (!value || typeof value !== "object") return false
+  const evidence = value as Record<string, unknown>
+  return evidence.materializedFiles === manifest.files.length
+    && evidence.materializedBytes === manifest.files.reduce((total, file) => total + file.size, 0)
 }
 
 function isSafeRuntimePath(path: string): boolean {
diff --git a/tests/cloudflare-runtime.test.ts b/tests/cloudflare-runtime.test.ts
@@ -220,7 +220,14 @@ test("WordPress runtime artifacts are content-addressed and reject unavailable o
     files: [{ path: "wordpress/wp-includes/version.php", size: source.byteLength, sha256: sha256(source) }],
   }
   const writes = new Map<string, Uint8Array>()
-  const php = { mkdir: () => {}, writeFile: (path: string, bytes: Uint8Array) => writes.set(path, bytes) }
+  const phpRuns: string[] = []
+  const php = {
+    writeFile: (path: string, bytes: Uint8Array) => writes.set(path, bytes),
+    run: async ({ code }: { code: string }) => {
+      phpRuns.push(code)
+      return { text: JSON.stringify({ materializedFiles: 1, materializedBytes: source.byteLength }) }
+    },
+  }
   let arrayBufferReads = 0
   const bucket = (bytes: Uint8Array | null) => ({ get: async () => bytes === null ? null : {
     size: bytes.byteLength,
@@ -239,10 +246,25 @@ test("WordPress runtime artifacts are content-addressed and reject unavailable o
   const hashCorruptManifest = { ...manifest, key: wordpressRuntimeArtifactKey("a".repeat(64)), archive: { ...manifest.archive, sha256: "a".repeat(64) } }
   await assert.rejects(materializeWordPressRuntimeArtifact(php, bucket(archive) as never, hashCorruptManifest), /archive hash does not match/)
   assert.equal(writes.size, 0, "hash-corrupt archives fail before extraction")
+  const malformed = new Uint8Array([0, 1, 2, 3])
+  const malformedManifest = { ...manifest, key: wordpressRuntimeArtifactKey(sha256(malformed)), archive: { sha256: sha256(malformed), size: malformed.byteLength } }
+  const malformedWrites: Uint8Array[] = []
+  await assert.rejects(materializeWordPressRuntimeArtifact({
+    writeFile: (_path, bytes) => malformedWrites.push(bytes),
+    run: async () => { throw new Error("WordPress runtime artifact ZIP could not be opened (ZipArchive status 19).") },
+  }, bucket(malformed) as never, malformedManifest), /ZIP could not be opened/)
+  assert.equal(malformedWrites.length, 1, "a hash-valid malformed archive is rejected by PHP after its single archive write")
   const evidence = await materializeWordPressRuntimeArtifact(php, bucket(archive) as never, manifest)
-  assert.equal(arrayBufferReads, 2, "valid and hash-corrupt archives use R2 arrayBuffer()")
+  assert.equal(arrayBufferReads, 3, "valid, hash-corrupt, and malformed archives use R2 arrayBuffer()")
   assert.deepEqual(evidence, { materializedFiles: 1, materializedBytes: source.byteLength })
-  assert.deepEqual(writes.get("/wordpress/wp-includes/version.php"), source)
+  assert.equal(writes.size, 1, "the verified archive crosses the JS/WASM boundary once")
+  assert.deepEqual(writes.get("/tmp/wp-codebox-wordpress-runtime.zip"), archive)
+  assert.equal(phpRuns.length, 1)
+  assert.match(phpRuns[0], /extension_loaded\('zip'\)/)
+  assert.match(phpRuns[0], /\$zip->numFiles !== count\(\$expected\)/)
+  assert.match(phpRuns[0], /\$zip->extractTo\('\/', array_keys\(\$expected\)\)/)
+  assert.match(phpRuns[0], /missing required file after extraction/)
+  assert.match(phpRuns[0], /finally \{\n    @unlink\(\$archive_path\)/)
 })
 
 test("WordPress runtime artifact validation rejects path traversal and invalid budgets", async () => {
@@ -253,8 +275,10 @@ test("WordPress runtime artifact validation rejects path traversal and invalid b
     source: { url: "https://downloads.wordpress.org/release/wordpress-6.8.1.zip" },
     files: [{ path: "wordpress/../wp-includes/version.php", size: 9 * 1024 * 1024, sha256: "b".repeat(64) }],
   }
-  const php = { mkdir: () => {}, writeFile: () => {} }
+  let writes = 0
+  const php = { writeFile: () => { writes++ }, run: async () => ({ text: "" }) }
   await assert.rejects(materializeWordPressRuntimeArtifact(php, { get: async () => null } as never, manifest), /invalid file path/)
+  assert.equal(writes, 0, "unsafe manifests are rejected before any archive write")
 })
 
 test("WordPress runtime corpus generator keeps the ZIP outside the Worker bundle", async () => {
@@ -265,7 +289,8 @@ test("WordPress runtime corpus generator keeps the ZIP outside the Worker bundle
   assert.match(generator, /encodeZip\(selected\)/)
   assert.match(generator, /lastModified: 0/)
   assert.match(generator, /artifacts\/cloudflare-wordpress-runtime-corpus\.zip/)
-  assert.match(artifact, /decodeZip\(new Blob\(\[archiveBytes\]\)\.stream\(\)\)/)
+  assert.doesNotMatch(artifact, /decodeZip/)
+  assert.match(artifact, /php\.writeFile\(WORDPRESS_RUNTIME_ARCHIVE_TEMP_PATH, archiveBytes\)/)
   assert.equal(manifest.key, wordpressRuntimeArtifactKey(manifest.archive.sha256))
   assert.ok(manifest.files.length > 0)
 })
