Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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.js
new file mode 100644
index 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 };
+};