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(indexeddb): validate factory receivers and preserve promise realms
ldm0b4f875566dbf
diff --git a/moli-core/tests/web_apis/fixtures/indexeddb-factory-receivers.js b/moli-core/tests/web_apis/fixtures/indexeddb-factory-receivers.jsnew file mode 100644index 000000000..90e52197f--- /dev/null+++ b/moli-core/tests/web_apis/fixtures/indexeddb-factory-receivers.js@@ -0,0 +1,101 @@+globalThis.factoryReceiverChecks = [];+async function factoryReceiverProbe(prefix = 'factory-receivers') {+ const checks = factoryReceiverChecks;+ const check = (label, pass, actual = '') => checks.push({label, pass, actual: String(actual)});+ const throws = (label, action, prototype) => {+ let caught;+ try { action(); } catch (error) { caught = error; }+ check(label, caught !== undefined && Object.getPrototypeOf(caught) === prototype, caught);+ };+ const exercise = async (label, Callee, Receiver) => {+ const prototype = Callee.IDBFactory.prototype;+ const factory = Receiver.indexedDB;+ const marker = new Error('argument must not be evaluated');+ let reads = 0;+ const name = {[Symbol.toPrimitive]() { ++reads; throw marker; }};+ const version = {valueOf() { ++reads; throw marker; }};+ const key = [1];+ Object.defineProperty(key, '0', {get() { ++reads; throw marker; }});+ const revoked = Proxy.revocable(factory, {}); revoked.revoke();+ let traps = 0;+ const trapped = new Proxy(factory, {+ get() { ++traps; throw marker; },+ getPrototypeOf() { ++traps; throw marker; },+ has() { ++traps; throw marker; }+ });+ const invalid = [+ ['null', null], ['undefined', undefined], ['number', 1], ['string', 'factory'],+ ['symbol', Symbol('factory')], ['ordinary', {}], ['prototype', Receiver.IDBFactory.prototype],+ ['forged', Object.create(Receiver.IDBFactory.prototype)], ['inherited', Object.create(factory)],+ ['proxy', new Proxy(factory, {})], ['revoked proxy', revoked.proxy], ['trapped proxy', trapped]+ ];+ const methods = [['open', [name, version]], ['deleteDatabase', [name]], ['cmp', [key, 1]]];+ for (const [kind, receiver] of invalid) {+ for (const [method, args] of methods) {+ reads = 0;+ throws(label + ': ' + method + ' rejects ' + kind,+ () => Reflect.apply(prototype[method], receiver, args), Callee.TypeError.prototype);+ check(label + ': ' + method + ' checks ' + kind + ' before conversion', reads === 0, reads);+ }+ throws(label + ': cmp rejects ' + kind + ' with valid keys',+ () => prototype.cmp.call(receiver, 1, 2), Callee.TypeError.prototype);+ let promise;+ let synchronousError;+ try { promise = prototype.databases.call(receiver, name); } catch (error) { synchronousError = error; }+ check(label + ': databases does not throw for ' + kind, synchronousError === undefined, synchronousError);+ check(label + ': databases rejection Promise realm for ' + kind,+ promise !== undefined && Object.getPrototypeOf(promise) === Callee.Promise.prototype);+ let synchronous = true;+ const settled = Promise.resolve(promise).then(+ () => ({error: undefined, synchronous}), error => ({error, synchronous}));+ synchronous = false;+ const rejection = await settled;+ check(label + ': databases rejects ' + kind + ' in callee realm',+ rejection.error !== undefined && Object.getPrototypeOf(rejection.error) === Callee.TypeError.prototype,+ rejection.error);+ check(label + ': databases rejection is asynchronous for ' + kind, !rejection.synchronous);+ }+ check(label + ': brand checks do not invoke Proxy traps', traps === 0, traps);+ for (const [method, args] of methods.slice(0, 2)) {+ reads = 0;+ let caught;+ try { Reflect.apply(prototype[method], factory, args); } catch (error) { caught = error; }+ check(label + ': valid ' + method + ' preserves conversion exception', caught === marker, caught);+ check(label + ': valid ' + method + ' evaluates argument once', reads === 1, reads);+ }+ for (const method of ['open', 'deleteDatabase', 'cmp']) {+ throws(label + ': ' + method + ' requires arguments',+ () => prototype[method].call(factory), Callee.TypeError.prototype);+ }+ throws(label + ': open rejects zero version in callee realm',+ () => prototype.open.call(factory, prefix, 0), Callee.TypeError.prototype);+ check(label + ': genuine receiver compares keys', prototype.cmp.call(factory, [1], [2]) === -1);+ for (const [method, length] of [['open', 1], ['deleteDatabase', 1], ['databases', 0], ['cmp', 2]]) {+ check(label + ': ' + method + ' length', prototype[method].length === length, prototype[method].length);+ }++ // Native receiver identity survives public prototype mutation. Keep promise+ // allocation and settlement with the factory when borrowing a foreign method.+ const originalPrototype = Object.getPrototypeOf(factory);+ try {+ Object.setPrototypeOf(factory, null);+ check(label + ': native brand survives prototype removal', prototype.cmp.call(factory, 1, 2) === -1);+ const ignored = new Proxy({}, {get() { throw new Error('databases ignores arguments'); }});+ const databases = prototype.databases.call(factory, ignored);+ check(label + ': successful databases Promise belongs to receiver', Object.getPrototypeOf(databases) === Receiver.Promise.prototype);+ const infos = await databases;+ check(label + ': genuine databases receiver settles', Array.isArray(infos));+ } finally { Object.setPrototypeOf(factory, originalPrototype); }+ };+ await exercise('local', globalThis, globalThis);+ if (typeof document !== 'undefined') {+ const frame = document.createElement('iframe');+ const loaded = new Promise(resolve => { frame.onload = resolve; });+ frame.srcdoc = '<!doctype html>'; document.documentElement.appendChild(frame); await loaded;+ try {+ await exercise('foreign-method', frame.contentWindow, globalThis);+ await exercise('foreign-receiver', globalThis, frame.contentWindow);+ } finally { frame.remove(); }+ }+ return {state: checks.every(check => check.pass) ? 'pass' : 'fail', checks};+}diff --git a/moli-core/tests/web_apis/indexed_db_transaction.rs b/moli-core/tests/web_apis/indexed_db_transaction.rsindex fcca85afa..379b1dda3 100644--- a/moli-core/tests/web_apis/indexed_db_transaction.rs+++ b/moli-core/tests/web_apis/indexed_db_transaction.rs@@ -1,6 +1,28 @@use super::pipe_disturbed::run_probe;use super::*;+#[tokio::test(flavor = "multi_thread")]+async fn indexed_db_factory_checks_native_receivers_and_rejects_promises_in_callee_realm()+-> Result<()> {+ let server = FixtureServer::spawn().await?;+ let browser = Browser::new(AppConfig::default())?;+ let fixture = include_str!("fixtures/indexeddb-factory-receivers.js");+ for target in ["window", "child", "worker"] {+ let source = format!(+ "{fixture}\nconst watchdog = setTimeout(() => finish({{state: 'timeout', checks: factoryReceiverChecks.slice(-12)}}), 5000); factoryReceiverProbe('factory-{target}').then(finish, error => finish({{state: 'error', error: String(error), checks: factoryReceiverChecks}})).finally(() => clearTimeout(watchdog));"+ );+ let result = run_probe(&browser, &server, target, &source).await?;+ assert_eq!(result["state"], "pass", "{target}: {result}");+ assert_eq!(+ result["checks"].as_array().unwrap().len(),+ if target == "worker" { 149 } else { 447 },+ "{target}: {result}"+ );+ }+ server.shutdown().await;+ Ok(())+}+#[tokio::test(flavor = "multi_thread")]async fn indexed_db_queries_snapshot_arguments_and_delete_key_ranges() -> Result<()> {let server = FixtureServer::spawn().await?;diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/database/factory/databases.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/database/factory/databases.rsindex 830568abb..77fa3ebeb 100644--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/database/factory/databases.rs+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/database/factory/databases.rs@@ -6,6 +6,13 @@ pub(in crate::context_bootstrap::indexed_db) fn idb_factory_databases_callback<'args: v8::FunctionCallbackArguments<'s>,mut rv: v8::ReturnValue<'s, v8::Value>,) {+ // The binding validates the receiver in the callee realm. Once it is valid,+ // keep the promise and settlement task in the factory's owning realm, just+ // like open/delete requests, including when a foreign method is borrowed.+ let Some(relevant_context) = args.this().get_creation_context(scope) else {+ return;+ };+ let scope = &mut v8::ContextScope::new(scope, relevant_context);let Some(resolver) = v8::PromiseResolver::new(scope) else {rv.set_undefined();return;diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors/factory_request.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors/factory_request.rsindex 8659ab52b..3d45eea60 100644--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors/factory_request.rs+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/install/constructors/factory_request.rs@@ -3,13 +3,13 @@ use crate::web_api_interfaces;use moli_webapi_declare::WebApiFunctionTemplate;#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::IDBFactory, enumerable)]+#[webapi(interface = web_api_interfaces::IDBFactory, enumerable, receiver)]struct IdbFactoryPrototypeDeclaration {- #[webapi(method, length = 2, callback = idb_factory_open_callback)]+ #[webapi(method, length = 1, callback = idb_factory_open_callback)]open: (),#[webapi(method, length = 1, callback = idb_factory_delete_database_callback)]delete_database: (),- #[webapi(method, length = 0, callback = idb_factory_databases_callback)]+ #[webapi(method, length = 0, callback = idb_factory_databases_callback, returns_promise)]databases: (),#[webapi(method, length = 2, callback = idb_factory_cmp_callback)]cmp: (),diff --git a/moli-renderer-v8/src/script_vm/tests/post_parse.rs b/moli-renderer-v8/src/script_vm/tests/post_parse.rsindex 91998ce50..95c2f476e 100644--- a/moli-renderer-v8/src/script_vm/tests/post_parse.rs+++ b/moli-renderer-v8/src/script_vm/tests/post_parse.rs@@ -4006,7 +4006,7 @@ fn indexed_db_declared_methods_have_webidl_operation_descriptors() {r#"(() => {const methods = [- [IDBFactory.prototype, "open", 2],+ [IDBFactory.prototype, "open", 1],[IDBFactory.prototype, "deleteDatabase", 1],[IDBFactory.prototype, "databases", 0],[IDBFactory.prototype, "cmp", 2],