Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.js
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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],