Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(encoding): validate decoder stream chunks with Web IDL
ldm041d392cdc588
diff --git a/moli-renderer-v8/src/context_bootstrap/stream_adapter/writable.rs b/moli-renderer-v8/src/context_bootstrap/stream_adapter/writable.rsindex ca1a1a570..c9aa2c186 100644--- a/moli-renderer-v8/src/context_bootstrap/stream_adapter/writable.rs+++ b/moli-renderer-v8/src/context_bootstrap/stream_adapter/writable.rs@@ -4,6 +4,7 @@ use super::transform_finish::{use super::*;use crate::text_codec::{TextCodecStore, TextDecodeError};use crate::util::get_private_value;+use crate::webidl;use moli_streams::queue::{QueueBounds, QueueRemainderPlan};use moli_streams::strategy::StrategySnapshot;use moli_streams::transform::{@@ -1117,11 +1118,21 @@ fn perform_transform_stream_write_in_relevant_realm<'s>(return None;}TransformWriteAlgorithm::TextDecoder => {- if let Some(bytes) = value_buffer_source_bytes(scope, chunk) {- return write_text_decoder_stream_chunk(scope, stream, readable, &bytes);- }- let error = text_decoder_stream_type_error_value(scope);- return reject_transform_stream_with_value(scope, stream, readable, error);+ let input = match webidl::convert::<webidl::AllowSharedBufferSource<'s>>(+ scope,+ chunk,+ webidl::Context::argument("TextDecoderStream", 1),+ ) {+ Ok(input) => input,+ Err(error) => {+ let message = v8::String::new(scope, &error.to_string())+ .expect("Web IDL conversion error message");+ let error = v8::Exception::type_error(scope, message);+ return reject_transform_stream_with_value(scope, stream, readable, error);+ }+ };+ let bytes = input.to_vec(scope);+ return write_text_decoder_stream_chunk(scope, stream, readable, &bytes);}TransformWriteAlgorithm::Callback => {let transformer = stream_slot_object(scope, stream, WRITABLE_STREAM_TRANSFORMER_SLOT)?;@@ -2601,15 +2612,6 @@ fn text_decode_error_value<'s>(v8::Exception::type_error(scope, v8str(scope, error.message()))}-fn text_decoder_stream_type_error_value<'s>(- scope: &mut v8::PinScope<'s, '_>,-) -> v8::Local<'s, v8::Value> {- v8::Exception::type_error(- scope,- v8str(scope, "TextDecoderStream chunk must be a BufferSource"),- )-}-pub(in crate::context_bootstrap) fn writable_stream_abort_internal<'s>(scope: &mut v8::PinScope<'s, '_>,stream: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/webidl_and_transform_streams.rs b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/webidl_and_transform_streams.rsindex c06080bf3..bbdb8f670 100644--- a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/webidl_and_transform_streams.rs+++ b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/webidl_and_transform_streams.rs@@ -638,6 +638,29 @@ fn text_decoder_stream_fatal_errors_reject_write_and_read() {);}+#[test]+fn text_decoder_stream_validates_buffer_sources_at_transform_time() {+ let mut vm = new_storage_test_vm("https://decoder-stream-buffer-source.test/");+ vm.eval(include_str!(+ "../../../../tests/fixtures/decoder-stream-buffer-source.js"+ ))+ .expect("decoder stream buffer source contract should load");+ vm.eval("runDecoderStreamSourceContract().then(result => globalThis.__decoderStreamSourceResults = result)")+ .expect("decoder stream buffer source contract should execute");+ let facts: serde_json::Value = serde_json::from_str(+ &vm.eval("JSON.stringify(__decoderStreamSourceResults)")+ .expect("decoder stream buffer source results should serialize"),+ )+ .expect("decoder stream buffer source results should be valid JSON");+ let checks = facts["checks"].as_array().expect("buffer source checks");+ let failures = checks+ .iter()+ .filter(|check| check["passed"] != true)+ .collect::<Vec<_>>();+ assert!(failures.is_empty(), "{failures:#?}");+ assert_eq!(checks.len(), 64);+}+#[test]fn text_decoder_stream_rejects_non_buffer_source_chunks() {let mut vm = new_storage_test_vm("https://example.com/");diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rsindex 9cf1b7450..7a73a937f 100644--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs@@ -1818,3 +1818,36 @@ runTextDecoderInputSnapshotContract().then(assert!(failures.is_empty(), "{failures:#?}");assert_eq!(checks.len(), 33);}++#[tokio::test]+async fn worker_text_decoder_stream_validates_buffer_sources_at_transform_time() {+ ensure_v8();+ let source = [+ include_str!("../../../../../tests/fixtures/decoder-stream-buffer-source.js"),+ r#"+runDecoderStreamSourceContract().then(+ result => { postMessage(result); close(); },+ error => { postMessage({ failure: String(error) }); close(); }+);+"#,+ ]+ .join("\n");+ let mut handle = spawn_worker(+ source,+ "https://decoder-stream-buffer-source.test/worker.js".into(),+ );+ let message = timeout(TIMEOUT, handle.recv())+ .await+ .expect("decoder stream buffer source contract should complete")+ .expect("worker result channel should stay open");+ handle.terminate_and_join();+ let facts: serde_json::Value = serde_json::from_str(&expect_post_json(message))+ .expect("decoder stream buffer source results should be valid JSON");+ let checks = facts["checks"].as_array().expect("buffer source checks");+ let failures = checks+ .iter()+ .filter(|check| check["passed"] != true)+ .collect::<Vec<_>>();+ assert!(failures.is_empty(), "{failures:#?}");+ assert_eq!(checks.len(), 64);+}diff --git a/moli-renderer-v8/tests/fixtures/decoder-stream-buffer-source.js b/moli-renderer-v8/tests/fixtures/decoder-stream-buffer-source.jsnew file mode 100644index 000000000..f211d6a0a--- /dev/null+++ b/moli-renderer-v8/tests/fixtures/decoder-stream-buffer-source.js@@ -0,0 +1,228 @@+globalThis.runDecoderStreamSourceContract = async function () {+ const checks = [];+ async function check(name, operation) {+ globalThis.__decoderStreamSourceProgress = name;+ try { checks.push({ name, passed: await operation() === true }); }+ catch (error) { checks.push({ name, passed: false, error: String(error) }); }+ }+ async function decode(value, fatal) {+ const source = new ReadableStream({+ start(controller) { controller.enqueue(value); controller.close(); },+ });+ const reader = source.pipeThrough(new TextDecoderStream("utf-8", { fatal })).getReader();+ const result = { chunks: [], error: undefined };+ try {+ while (true) {+ const item = await reader.read();+ if (item.done) break;+ result.chunks.push(item.value);+ }+ } catch (error) { result.error = error; }+ return result;+ }+ const valid = [+ ["buffer", () => Uint8Array.of(65).buffer],+ ["view", () => Uint8Array.of(0, 65, 0).subarray(1, 2)],+ ["DataView", () => {+ const bytes = Uint8Array.of(0, 65, 0);+ return new DataView(bytes.buffer, 1, 1);+ }],+ ["shared buffer", () => {+ const bytes = new Uint8Array(new SharedArrayBuffer(1));+ bytes[0] = 65;+ return bytes.buffer;+ }],+ ["shared view", () => {+ const bytes = new Uint8Array(new SharedArrayBuffer(3));+ bytes[1] = 65;+ return bytes.subarray(1, 2);+ }],+ ["shared DataView", () => {+ const bytes = new Uint8Array(new SharedArrayBuffer(3));+ bytes[1] = 65;+ return new DataView(bytes.buffer, 1, 1);+ }],+ ];+ for (const kind of ["buffer", "view", "DataView"]) {+ valid.push([`detached ${kind}`, () => {+ const bytes = Uint8Array.of(65);+ const input = kind === "buffer" ? bytes.buffer : kind === "view" ? bytes : new DataView(bytes.buffer);+ bytes.buffer.transfer(0);+ return input;+ }]);+ }+ for (const fatal of [false, true]) {+ for (const [name, make] of valid) {+ await check(`valid ${name}, fatal=${fatal}`, async () => {+ const input = make();+ const result = await decode(input, fatal);+ const expected = name.startsWith("detached") ? [] : ["A"];+ return result.error === undefined && JSON.stringify(result.chunks) === JSON.stringify(expected);+ });+ }+ }+ const invalid = [+ ["Proxy", () => new Proxy(Uint8Array.of(65), {})],+ ["revoked Proxy", () => {+ const { proxy, revoke } = Proxy.revocable(Uint8Array.of(65), {});+ revoke();+ return proxy;+ }],+ ];+ for (const shared of [false, true]) {+ for (const kind of ["buffer", "view", "DataView"]) {+ invalid.push([`${shared ? "growable shared" : "resizable"} ${kind}`, () => {+ const buffer = shared ? new SharedArrayBuffer(1, { maxByteLength: 2 }) :+ new ArrayBuffer(1, { maxByteLength: 2 });+ new Uint8Array(buffer)[0] = 65;+ return kind === "buffer" ? buffer : kind === "view" ? new Uint8Array(buffer) : new DataView(buffer);+ }]);+ }+ }+ for (const fatal of [false, true]) {+ for (const [name, make] of invalid) {+ await check(`reject ${name}, fatal=${fatal}`, async () => {+ const input = make();+ const result = await decode(input, fatal);+ return result.error instanceof TypeError && result.chunks.length === 0;+ });+ }+ }+ await check("snapshot when queued transform runs", async () => {+ const input = Uint8Array.of(65);+ const stream = new TextDecoderStream();+ const writer = stream.writable.getWriter();+ const reader = stream.readable.getReader();+ const write = writer.write(input);+ input[0] = 66;+ const first = await reader.read();+ await write;+ const close = writer.close();+ const last = await reader.read();+ await close;+ return !first.done && first.value === "B" && last.done;+ });+ for (const [name, make] of valid.slice(0, 6)) {+ await check(`ignore author buffer getters: ${name}`, async () => {+ const input = make();+ let reads = 0;+ for (const key of ["buffer", "byteOffset", "byteLength"]) {+ Object.defineProperty(input, key, { get() { reads++; throw Error(key); } });+ }+ const result = await decode(input, false);+ return result.error === undefined && result.chunks.join("") === "A" && reads === 0;+ });+ }+ for (const fatal of [false, true]) {+ for (const kind of ["buffer", "view", "DataView"]) {+ await check(`reject detached resizable ${kind}, fatal=${fatal}`, async () => {+ const buffer = new ArrayBuffer(1, { maxByteLength: 2 });+ const input = kind === "buffer" ? buffer : kind === "view" ? new Uint8Array(buffer) : new DataView(buffer);+ buffer.transfer(0);+ const result = await decode(input, fatal);+ return result.error instanceof TypeError && result.chunks.length === 0;+ });+ }+ }+ const identityInputs = [+ ["null", () => null],+ ["object", () => ({})],+ ["author Proxy", trap => new Proxy(Uint8Array.of(65), {+ get() { trap(); }, has() { trap(); }, getPrototypeOf() { trap(); },+ })],+ invalid[1],+ ["resizable buffer", () => new ArrayBuffer(1, { maxByteLength: 2 })],+ ["growable shared view", () => new Uint8Array(new SharedArrayBuffer(1, { maxByteLength: 2 }))],+ ["detached resizable buffer", () => {+ const buffer = new ArrayBuffer(1, { maxByteLength: 2 });+ buffer.transfer(0);+ return buffer;+ }],+ ];+ const rejection = promise => promise.then(() => undefined, error => error);+ for (const [name, make] of identityInputs) {+ await check(`asynchronous error identity: ${name}`, async () => {+ let traps = 0;+ const input = make(() => { traps++; throw Error("Proxy trap"); });+ const stream = new TextDecoderStream();+ const writer = stream.writable.getWriter();+ const reader = stream.readable.getReader();+ const read = rejection(reader.read());+ const readerClosed = rejection(reader.closed);+ const writerClosed = rejection(writer.closed);+ let write;+ try { write = writer.write(input); }+ catch (error) { await reader.cancel().catch(() => {}); return false; }+ const ready = rejection(writer.ready);+ const error = await rejection(write);+ if (!(error instanceof TypeError)) {+ await reader.cancel("unexpectedly accepted input").catch(() => {});+ return false;+ }+ const subsequentWrite = rejection(writer.write(Uint8Array.of(65)));+ const errors = await Promise.all([read, readerClosed, writerClosed, ready, subsequentWrite]);+ return write instanceof Promise && traps === 0 && errors.every(value => value === error);+ });+ }+ for (const kind of ["buffer", "DataView", "shared buffer", "shared view",+ "detached buffer", "detached view", "detached DataView"]) {+ await check(`queued input mutation: ${kind}`, async () => {+ const shared = kind.startsWith("shared");+ const detach = kind.startsWith("detached");+ const buffer = shared ? new SharedArrayBuffer(3) : new ArrayBuffer(3);+ const bytes = new Uint8Array(buffer);+ bytes[1] = 65;+ const input = kind.endsWith("DataView") ? new DataView(buffer, 1, 1) :+ kind.endsWith("view") ? bytes.subarray(1, 2) : buffer;+ if (input === buffer) bytes.fill(65);+ const stream = new TextDecoderStream();+ const writer = stream.writable.getWriter();+ const reader = stream.readable.getReader();+ const write = writer.write(input);+ if (detach) buffer.transfer(0);+ else if (shared) for (let index = 0; index < bytes.length; index++) Atomics.store(bytes, index, 66);+ else bytes.fill(66);+ const read = reader.read();+ read.catch(() => {});+ await write;+ const close = writer.close();+ const first = await read;+ if (detach) { await close; return first.done; }+ const last = await reader.read();+ await close;+ return !first.done && first.value === (input === buffer ? "BBB" : "B") && last.done;+ });+ }+ for (const [name, make] of [invalid[0], identityInputs[4]]) {+ await check(`cancel before queued conversion: ${name}`, async () => {+ const input = make();+ const stream = new TextDecoderStream();+ const writer = stream.writable.getWriter();+ const reader = stream.readable.getReader();+ const closed = rejection(writer.closed);+ let settled = false;+ const write = writer.write(input).then(+ () => { settled = true; }, error => { settled = true; return error; });+ await Promise.resolve();+ await Promise.resolve();+ const wasPending = !settled;+ const reason = {};+ await reader.cancel(reason);+ return wasPending && await write === reason && await closed === reason;+ });+ }+ await check("shared UTF-8 prefix survives to fixed trailing chunk", async () => {+ const prefix = new SharedArrayBuffer(1);+ new Uint8Array(prefix)[0] = 0xe2;+ const source = new ReadableStream({ start(controller) {+ controller.enqueue(prefix);+ controller.enqueue(Uint8Array.of(0x82, 0xac));+ controller.close();+ } });+ const reader = source.pipeThrough(new TextDecoderStream("utf-8", { fatal: true })).getReader();+ const first = await reader.read();+ const last = await reader.read();+ return !first.done && first.value === "\u20ac" && last.done;+ });+ return { checks };+};