Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(file-api): avoid overflow when normalizing Blob slice offsets

ldm00873cc83d5f6
diff --git a/moli-file-api/src/lib.rs b/moli-file-api/src/lib.rs
index b160c7ed2..25f376ec6 100644
--- a/moli-file-api/src/lib.rs
+++ b/moli-file-api/src/lib.rs
@@ -59,10 +59,11 @@ pub fn clamp_blob_long_long(value: f64) -> i64 {
}
pub fn blob_slice_relative_index(index: i64, size: usize) -> usize {
+ let magnitude = usize::try_from(index.unsigned_abs()).unwrap_or(usize::MAX);
if index < 0 {
- size.saturating_sub((-index) as usize)
+ size.saturating_sub(magnitude)
} else {
- (index as usize).min(size)
+ magnitude.min(size)
}
}
@@ -208,6 +209,35 @@ mod tests {
assert_eq!(blob_slice_relative_index(-20, 10), 0);
}
+ #[test]
+ fn blob_slice_relative_index_handles_signed_extremes_for_all_sizes() {
+ for size in [0, 1, 4, usize::MAX / 2 + 1, usize::MAX] {
+ for index in [
+ i64::MIN,
+ i64::MIN + 1,
+ -4,
+ -1,
+ 0,
+ 1,
+ 4,
+ i64::MAX - 1,
+ i64::MAX,
+ ] {
+ let relative = if index < 0 {
+ size as i128 + i128::from(index)
+ } else {
+ i128::from(index)
+ };
+ let expected = relative.clamp(0, size as i128) as usize;
+ assert_eq!(
+ blob_slice_relative_index(index, size),
+ expected,
+ "index={index}, size={size}"
+ );
+ }
+ }
+ }
+
#[test]
fn blob_mime_type_uses_web_api_normalization() {
assert_eq!(
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/blob_slice.rs b/moli-renderer-v8/src/runtime/page_vm/tests/blob_slice.rs
new file mode 100644
index 000000000..bc25653b5
--- /dev/null
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/blob_slice.rs
@@ -0,0 +1,50 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn blob_slice_boundaries_do_not_overflow_in_window_or_worker() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let (mut page, _resource_source, _owner_wake) =
+ page_vm_with_bound_task_sources_and_owner_wake(
+ &loader,
+ Url::parse("https://blob-slice-boundaries.test/")?,
+ );
+ page.vm_mut().eval(include_str!(
+ "../../../../tests/fixtures/blob-slice-boundaries.js"
+ ))?;
+ let deadline = Instant::now() + Duration::from_secs(20);
+ while page.vm_mut().eval("typeof __uiEventResults")? == "undefined" {
+ let _ = page
+ .run_next_child_frame_task_source_for_semantic_test()
+ .await;
+ for selector in [
+ PageSelectedTaskTestSelector::ResourceCompletion,
+ PageSelectedTaskTestSelector::WorkerHostBridge,
+ PageSelectedTaskTestSelector::DedicatedWorkerClientEvent,
+ ] {
+ let _ = page
+ .run_exact_selected_page_task_for_test(selector, &loader)
+ .await?;
+ }
+ anyhow::ensure!(
+ Instant::now() < deadline,
+ "Blob slice fixture did not finish: {}",
+ page.vm_mut().eval("JSON.stringify(__blobSliceProgress)")?
+ );
+ tokio::time::sleep(Duration::from_millis(1)).await;
+ }
+ let facts: serde_json::Value =
+ serde_json::from_str(&page.vm_mut().eval("JSON.stringify(__uiEventResults)")?)?;
+ let checks = facts["checks"].as_array().unwrap();
+ let failures = checks
+ .iter()
+ .filter(|check| check["passed"] != true)
+ .collect::<Vec<_>>();
+ assert!(failures.is_empty(), "{failures:#?}");
+ assert_eq!(checks.len(), 360);
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("Blob slice handles signed limits and clamped indices in every realm");
+}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
index 56d32a2f3..3b3e7b26b 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs
@@ -98,6 +98,7 @@ use crate::native_bridge::PendingWindowMessageEndpoint;
mod accessibility;
mod async_subresource_completion;
+mod blob_slice;
mod broadcast_channel_delivery;
mod child_classic_source_load_completion;
mod child_document_completion;
diff --git a/moli-renderer-v8/tests/fixtures/blob-slice-boundaries.js b/moli-renderer-v8/tests/fixtures/blob-slice-boundaries.js
new file mode 100644
index 000000000..3f1357af7
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/blob-slice-boundaries.js
@@ -0,0 +1,80 @@
+(async () => {
+ const checks = [];
+ globalThis.__blobSliceProgress = {stage: 'setup', checks};
+ async function runMatrix(owner, callee, prefix, checks) {
+ const edges = [
+ ['negative infinity', -Infinity, 'data', ''],
+ ['negative finite limit', -Number.MAX_VALUE, 'data', ''],
+ ['signed minimum', -(2 ** 63), 'data', ''],
+ ['below signed minimum', -(2 ** 63) - 2048, 'data', ''],
+ ['positive finite limit', Number.MAX_VALUE, '', 'data'],
+ ['positive infinity', Infinity, '', 'data'],
+ ['above signed maximum', 2 ** 63, '', 'data'],
+ ['zero', 0, 'data', ''],
+ ['negative zero', -0, 'data', ''],
+ ['negative one', -1, 'a', 'dat'],
+ ['negative half', -0.5, 'data', ''],
+ ['negative tie', -1.5, 'ta', 'da'],
+ ['positive tie', 1.5, 'ta', 'da'],
+ ['positive half', 0.5, 'data', ''],
+ ['NaN', NaN, 'data', '']
+ ];
+ for (const kind of ['Blob', 'File']) {
+ const source = kind === 'Blob' ? new owner.Blob(['data']) : new owner.File(['data'], 'file.txt');
+ const empty = kind === 'Blob' ? new owner.Blob() : new owner.File([], 'empty.txt');
+ const slice = callee.Blob.prototype.slice;
+ for (const [name, value, startText, endText] of edges) {
+ for (const [position, args, expected] of [['start', [value], startText], ['end', [0, value], endText]]) {
+ const label = `${prefix}/${kind}/${name}/${position}`;
+ if (globalThis.__blobSliceProgress) globalThis.__blobSliceProgress.stage = label;
+ const result = slice.call(source, ...args);
+ const text = await result.text();
+ checks.push({name: label, passed: text === expected && result.size === expected.length && result.type === '', detail: {text, size: result.size, expected}});
+ }
+ }
+ for (const value of [-Infinity, 0, Infinity]) {
+ for (const [position, args] of [['start', [value]], ['end', [0, value]]]) {
+ const label = `${prefix}/${kind}/empty/${value}/${position}`;
+ const result = slice.call(empty, ...args);
+ const text = await result.text();
+ checks.push({name: label, passed: result.size === 0 && text === '', detail: {text, size: result.size}});
+ }
+ }
+ }
+ }
+ const frame = document.createElement('iframe');
+ document.body.appendChild(frame);
+ const realms = [['top', window], ['child', frame.contentWindow]];
+ for (const [ownerName, owner] of realms) {
+ for (const [calleeName, callee] of realms) {
+ await runMatrix(owner, callee, `${ownerName}/${calleeName}`, checks);
+ }
+ }
+ __blobSliceProgress.stage = 'worker boundaries';
+ const workerBody = async runMatrix => {
+ const checks = [];
+ await runMatrix(globalThis, globalThis, 'worker', checks);
+ postMessage(checks);
+ close();
+ };
+ const url = URL.createObjectURL(new Blob([
+ `(${workerBody.toString()})(${runMatrix.toString()})`
+ ], {type: 'text/javascript'}));
+ const worker = new Worker(url);
+ try {
+ const workerChecks = await new Promise((resolve, reject) => {
+ worker.onmessage = event => resolve(event.data);
+ worker.onerror = event => reject(Error(event.message));
+ });
+ checks.push(...workerChecks);
+ } finally {
+ worker.terminate();
+ URL.revokeObjectURL(url);
+ frame.remove();
+ }
+ globalThis.__uiEventResults = {checks};
+})().catch(error => {
+ const checks = globalThis.__blobSliceProgress.checks;
+ checks.push({name: 'fixture completion', passed: false, detail: String(error.stack || error)});
+ globalThis.__uiEventResults = {checks};
+});