Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
use crate::script_vm::{RuntimeEvaluateCodeGenerationPolicy, RuntimeEvaluateResultMode};
fn native_element_handle_by_id(vm: &ScriptVm, id: &str) -> DomHandle {
vm.document_runtime
.dom_host()
.dom()
.nodes()
.iter()
.enumerate()
.find_map(|(index, node)| {
let element = node.as_element()?;
(element.attribute("id") == Some(id)).then_some(DomHandle::new(index))
})
.unwrap_or_else(|| panic!("element #{id} should have a native handle"))
}
use moli_browser_profile::{
DEFAULT_USER_AGENT, DEFAULT_WINDOW_SURFACE_PROFILE, navigator_app_version,
};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
task::JoinHandle,
};
use super::service_worker_drain::{
drain_service_worker_test_turn, drain_service_worker_test_until_eval_equals,
drain_service_worker_test_until_popup_loads_settle,
run_service_worker_client_focus_request_task_for_test,
run_service_worker_client_navigate_request_task_for_test,
run_service_worker_clients_open_window_request_task_for_test,
};
fn service_worker_window_client_target_for_test(
client_id: crate::runtime::ServiceWorkerClientId,
document_owner: crate::native_bridge::WindowDocumentOwner,
) -> crate::types::ServiceWorkerWindowClientTarget {
crate::types::ServiceWorkerWindowClientTarget {
client_id,
document_owner,
}
}
fn service_worker_csp_report_seen(
items: &[crate::types::ScriptNetworkOutputItem],
report_url: &str,
expected_body: &str,
) -> bool {
let report_handle = items.iter().find_map(|item| {
let crate::types::ScriptNetworkOutputItem::SubresourceRequestStarted(request) = item else {
return None;
};
(request.resource_type() == crate::types::SubresourceResourceType::CspReport
&& request.url().as_str() == report_url)
.then(|| request.handle())
});
let report_body_seen = report_handle.is_some_and(|handle| {
items.iter().any(|item| {
matches!(
item,
crate::types::ScriptNetworkOutputItem::SubresourceBodyFinished(body)
if body.handle() == handle
&& matches!(
body.result(),
crate::types::SubresourceBodyFinishedResult::Ready(response_body)
if response_body.diagnostic_bytes().as_ref() == expected_body.as_bytes()
)
)
})
});
let report_record_seen = items.iter().any(|item| {
matches!(
item,
crate::types::ScriptNetworkOutputItem::SubresourceNetworkRecord(record)
if record.url().as_str() == report_url
&& record.resource_type() == crate::types::SubresourceResourceType::CspReport
&& matches!(
record.outcome(),
crate::types::SubresourceNetworkOutcome::Success {
status: 200,
final_url,
response_body,
..
} if final_url.as_str() == report_url
&& response_body.diagnostic_bytes().as_ref() == expected_body.as_bytes()
)
)
});
report_body_seen || report_record_seen
}
async fn assert_popup_consecutive_history_back(from_popup: bool) {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm =
new_page_task_executor_test_vm_with_loader("https://example.com/page.html", &loader);
vm.eval(&format!("globalThis.traverseFromPopup = {from_popup}"))
.expect("traversal initiator should evaluate");
vm.eval(
r#"
globalThis.popupTraversalLoads = [];
globalThis.popupTraversalUrls = [0, 1, 2].map(index =>
URL.createObjectURL(new Blob([`<!doctype html><script>
onload = () => {
opener.popupTraversalLoads.push(${index});
if (${index} === 2 && opener.traverseFromPopup) {
history.go(-10);
history.back();
history.back();
}
};
<\/script>`], {type:'text/html'})));
"#,
)
.expect("popup traversal fixtures should evaluate");
for index in 0..3 {
vm.eval(&format!(
"globalThis.traversalPopup = open(popupTraversalUrls[{index}], 'consecutiveHistoryPopup')"
))
.expect("popup navigation should evaluate");
let expected = match index {
0 => "0",
1 => "0,1",
_ if from_popup => "0,1,2,1",
_ => "0,1,2",
};
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"popupTraversalLoads.join(',')",
expected,
"popup documents should load in traversal order",
)
.await;
}
if !from_popup {
vm.eval("traversalPopup.history.back(); traversalPopup.history.back()")
.expect("the opener should request both traversals through the outgoing History");
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"popupTraversalLoads.join(',')",
"0,1,2,1",
"only the first traversal from the outgoing popup History should commit",
)
.await;
}
assert_eq!(
vm.eval("String(traversalPopup.location.href === popupTraversalUrls[1])")
.expect("popup traversal destination should evaluate"),
"true"
);
vm.eval("traversalPopup.history.back()")
.expect("the restored Document's History should allow another traversal");
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"popupTraversalLoads.join(',')",
"0,1,2,1,0",
"completed popup loads must release the pending traversal",
)
.await;
}
async fn assert_sandbox_child_about_blank_popup_reloads_self_and_messages_top(
sandbox: &str,
expected_popup_origin_prefix: &str,
) {
let (helper_url, server) = spawn_sandbox_popup_helper_server().await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let helper_url_parsed = Url::parse(&helper_url).expect("helper url");
let document_url = format!(
"http://127.0.0.1:{}/parent.html",
helper_url_parsed
.port()
.expect("helper url should carry a port")
);
let mut vm = new_storage_page_task_executor_test_vm_with_loader(&document_url, &loader);
let helper_url_literal = serde_json::to_string(&helper_url).expect("serialize helper url");
let sandbox_literal = serde_json::to_string(sandbox).expect("serialize sandbox");
let setup = vm
.eval(&format!(
r#"
(() => {{
globalThis.__sandboxPopupMessages = [];
addEventListener("message", event => {{
__sandboxPopupMessages.push({{
origin: event.origin,
data: event.data,
sourceIsFrame: event.source === frame.contentWindow
}});
}});
const frame = document.createElement("iframe");
frame.sandbox = {sandbox_literal};
frame.src = {helper_url_literal};
(document.body || document.documentElement || document).appendChild(frame);
return "queued";
}})()
"#
))
.expect("sandbox popup helper setup should evaluate");
assert_eq!(setup, "queued");
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"__sandboxPopupMessages.length",
"1",
"sandbox popup message",
)
.await;
server
.await
.expect("sandbox popup helper server should finish");
let result = vm
.eval("JSON.stringify(__sandboxPopupMessages)")
.expect("sandbox popup messages should evaluate");
if expected_popup_origin_prefix == "null" {
assert_eq!(
result,
r#"[{"origin":"null","data":{"origin":"null"},"sourceIsFrame":true}]"#
);
} else {
assert!(
result.contains(r#""origin":"null""#),
"sandbox child should still message top with opaque origin: {result}"
);
assert!(
result.contains(expected_popup_origin_prefix),
"escaped popup should report non-opaque opener event origin: {result}"
);
}
}
async fn lightweight_popup_nested_eval_result(
opener_policy: &'static str,
popup_policy_header: &'static str,
expected: &'static str,
) -> String {
let (popup_url, server) = spawn_lightweight_popup_response_html_server(
"popup nested eval policy test server",
"popup nested eval policy",
popup_policy_header,
r#"<!doctype html><script>
trustedTypes.createPolicy("default", {
createScript: (value, _type, sink) => sink === "Location href" ? value : null
});
onload = () => {
location.href = `javascript:
try {
eval("globalThis.__popupNestedEvalRan = true");
opener.postMessage("allowed", "*");
} catch (error) {
opener.postMessage(error.name, "*");
}
`;
};
</script>"#,
)
.await;
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let document_url = Url::parse(&popup_url)
.expect("popup url")
.join("/base/page.html")
.expect("document url");
let mut vm = new_storage_page_task_executor_test_vm_with_loader(document_url.as_str(), &loader);
vm.set_response_content_security_policies(&[opener_policy.to_owned()]);
let popup_url_literal = serde_json::to_string(&popup_url).expect("serialize popup url");
vm.eval(&format!(
r#"
globalThis.__popupNestedEvalResult = "pending";
addEventListener("message", event => {{
globalThis.__popupNestedEvalResult = String(event.data);
}});
open({popup_url_literal});
"#
))
.expect("popup nested eval setup should evaluate");
wait_for_one_page_resource_completion_selected_task_executor_test_turn(
&mut vm,
&loader,
"popup nested eval document completion",
)
.await;
server
.await
.expect("popup nested eval policy server should finish");
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"String(globalThis.__popupNestedEvalResult)",
expected,
"popup nested eval policy result",
)
.await;
vm.eval("String(globalThis.__popupNestedEvalResult)")
.expect("popup nested eval result should evaluate")
}
async fn spawn_lightweight_popup_204_then_loaded_server()
-> (String, String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind popup 204 loaded test server");
let addr = listener.local_addr().expect("popup 204 loaded server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener.accept().await.expect("accept popup 204 request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read popup 204 request");
let response = "HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
stream
.write_all(response.as_bytes())
.await
.expect("write popup 204 response");
let (mut stream, _) = listener
.accept()
.await
.expect("accept popup loaded request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read popup loaded request");
let body = r#"<!doctype html><script>window.onload = () => window.opener.postMessage("loaded", "*");</script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write popup loaded response");
});
(
format!("http://{addr}/popup-204.html"),
format!("http://{addr}/base/loaded.html"),
server,
)
}
async fn spawn_lightweight_popup_relative_navigation_server()
-> (String, tokio::task::JoinHandle<Vec<String>>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind popup relative navigation test server");
let addr = listener
.local_addr()
.expect("popup relative navigation server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let mut request_paths = Vec::new();
for _ in 0..2 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept popup relative navigation request");
let mut buffer = [0; 2048];
let read = stream
.read(&mut buffer)
.await
.expect("read popup relative navigation request");
let request = String::from_utf8_lossy(&buffer[..read]);
let request_path = request
.lines()
.next()
.and_then(|line| line.split_ascii_whitespace().nth(1))
.expect("popup relative navigation request target")
.to_owned();
request_paths.push(request_path);
let body = r#"<!doctype html><script>window.onload = () => window.opener.postMessage("loaded", "*");</script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write popup relative navigation response");
}
request_paths
});
(format!("http://{addr}"), server)
}
async fn spawn_lightweight_popup_response_csp_server() -> (String, tokio::task::JoinHandle<()>) {
spawn_lightweight_popup_response_html_server(
"popup response CSP test server",
"popup response CSP",
"Content-Security-Policy: script-src 'none'",
r#"<!doctype html><script>opener.__popupResponseCspEvents.push("script");</script>"#,
)
.await
}
async fn spawn_lightweight_popup_response_html_server(
bind_label: &'static str,
io_label: &'static str,
policy_header: &'static str,
body: &'static str,
) -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.unwrap_or_else(|_| panic!("bind {bind_label}"));
let addr = listener
.local_addr()
.unwrap_or_else(|_| panic!("{bind_label} addr"));
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener
.accept()
.await
.unwrap_or_else(|_| panic!("accept {io_label} request"));
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.unwrap_or_else(|_| panic!("read {io_label} request"));
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n{policy_header}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.unwrap_or_else(|_| panic!("write {io_label} response"));
});
(format!("http://{addr}/popup.html"), server)
}
async fn spawn_lightweight_popup_document_domain_server(
policy_header: Option<&'static str>,
) -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind popup document-domain test server");
let addr = listener
.local_addr()
.expect("popup document-domain server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener
.accept()
.await
.expect("accept popup document-domain request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read popup document-domain request");
let body = "<!doctype html><title>popup</title>";
let policy_header = policy_header
.map(|header| format!("{header}\r\n"))
.unwrap_or_default();
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n{}Content-Length: {}\r\nConnection: close\r\n\r\n{}",
policy_header,
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write popup document-domain response");
});
(format!("http://{addr}/popup.html"), server)
}
async fn spawn_storage_bucket_partition_child_server() -> (String, JoinHandle<String>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind storage bucket partition child server");
let addr = listener
.local_addr()
.expect("storage bucket partition child server addr");
let server = tokio::spawn(async move {
let (mut stream, _) = listener
.accept()
.await
.expect("accept storage bucket partition child request");
let request = read_storage_bucket_partition_request_head(&mut stream)
.await
.expect("read storage bucket partition child request");
let status = if request.starts_with("GET /storage-bucket-child.html ") {
"200 OK"
} else {
"404 Not Found"
};
let body = r#"<!doctype html>
<meta charset="utf-8">
<script>
(async () => {
const bucket = await navigator.storageBuckets.open("partitioned-bucket");
parent.postMessage(JSON.stringify({
bucketName: bucket.name,
keys: await navigator.storageBuckets.keys()
}), "*");
})().catch(error => {
parent.postMessage("error:" + (error && error.name), "*");
});
</script>"#;
let response = format!(
"HTTP/1.1 {status}\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write storage bucket partition child response");
request
});
(
format!("http://localhost:{}/storage-bucket-child.html", addr.port()),
server,
)
}
async fn spawn_service_worker_response_server(
responses: Vec<(&'static str, &'static str, &'static str)>,
) -> (String, JoinHandle<()>) {
spawn_service_worker_response_server_with_headers(
responses
.into_iter()
.map(|(path, content_type, body)| (path, content_type, Vec::new(), body))
.collect(),
)
.await
}
async fn spawn_service_worker_response_server_with_headers(
responses: Vec<(
&'static str,
&'static str,
Vec<(&'static str, &'static str)>,
&'static str,
)>,
) -> (String, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind service worker response server");
let addr = listener
.local_addr()
.expect("service worker response server addr");
let server = tokio::spawn(async move {
let mut responses: std::collections::VecDeque<_> = responses.into_iter().collect();
while let Some((expected_path, content_type, extra_headers, body)) = responses.pop_front() {
let (mut stream, _) = listener
.accept()
.await
.expect("accept service worker response request");
let request = read_storage_bucket_partition_request_head(&mut stream)
.await
.expect("read service worker response request");
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("service worker response request path");
assert_eq!(path, expected_path);
let extra_headers = extra_headers
.into_iter()
.map(|(name, value)| format!("{name}: {value}\r\n"))
.collect::<String>();
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\n{extra_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write service worker response");
}
});
(format!("http://127.0.0.1:{}", addr.port()), server)
}
async fn spawn_service_worker_redirect_response_server() -> (String, JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind service worker redirect response server");
let addr = listener
.local_addr()
.expect("service worker redirect response server addr");
let server = tokio::spawn(async move {
for _ in 0..3 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept service worker redirect response request");
let request = read_storage_bucket_partition_request_head(&mut stream)
.await
.expect("read service worker redirect response request");
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("service worker redirect response request path");
assert_eq!(path, "/redirect-start");
let response = concat!(
"HTTP/1.1 302 Found\r\n",
"Location: /redirect-target\r\n",
"Access-Control-Allow-Origin: *\r\n",
"Content-Length: 0\r\n",
"Connection: close\r\n",
"\r\n"
);
stream
.write_all(response.as_bytes())
.await
.expect("write service worker redirect response");
}
});
(
format!("http://127.0.0.1:{}/redirect-start", addr.port()),
server,
)
}
async fn spawn_service_worker_headers_first_body_server()
-> (String, JoinHandle<()>, tokio::sync::oneshot::Sender<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind service worker headers-first server");
let addr = listener
.local_addr()
.expect("service worker headers-first server addr");
let (release_body_tx, release_body_rx) = tokio::sync::oneshot::channel::<()>();
let server = tokio::spawn(async move {
let (mut worker_stream, _) = listener
.accept()
.await
.expect("accept service worker script request");
let request = read_storage_bucket_partition_request_head(&mut worker_stream)
.await
.expect("read service worker script request");
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("service worker script request path");
assert_eq!(path, "/app/worker.js");
let worker_body = r#"
self.addEventListener("install", event => {
event.waitUntil(Promise.resolve());
});
self.addEventListener("activate", event => {
event.waitUntil(clients.claim());
});
self.addEventListener("fetch", event => {
event.respondWith(fetch(event.request));
});
"#;
let worker_response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/javascript; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
worker_body.len(),
worker_body
);
worker_stream
.write_all(worker_response.as_bytes())
.await
.expect("write service worker script response");
let (mut api_stream, _) = listener
.accept()
.await
.expect("accept service worker proxied API request");
let request = read_storage_bucket_partition_request_head(&mut api_stream)
.await
.expect("read service worker proxied API request");
let path = request
.lines()
.next()
.and_then(|line| line.split_whitespace().nth(1))
.expect("service worker proxied API request path");
assert_eq!(path, "/app/api/headers-first.txt");
let body = "delayed-body";
let headers = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
api_stream
.write_all(headers.as_bytes())
.await
.expect("write service worker proxied API headers");
api_stream
.flush()
.await
.expect("flush service worker proxied API headers");
let _ = release_body_rx.await;
let _ = api_stream.write_all(body.as_bytes()).await;
});
(
format!("http://127.0.0.1:{}", addr.port()),
server,
release_body_tx,
)
}
async fn spawn_service_worker_script_server(paths: Vec<&'static str>) -> (String, JoinHandle<()>) {
spawn_service_worker_response_server(
paths
.into_iter()
.map(|path| {
(
path,
"text/javascript; charset=utf-8",
"self.addEventListener('install', () => {});",
)
})
.collect(),
)
.await
}
fn service_worker_http_cache_test_root(label: &str) -> std::path::PathBuf {
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("system clock should be after epoch")
.as_nanos();
std::env::temp_dir().join(format!(
"moli-renderer-v8-service-worker-http-cache-{label}-{}-{nonce}",
std::process::id()
))
}
async fn read_storage_bucket_partition_request_head(
stream: &mut tokio::net::TcpStream,
) -> std::io::Result<String> {
let mut buf = Vec::new();
let mut chunk = [0_u8; 512];
loop {
let n = stream.read(&mut chunk).await?;
if n == 0 {
break;
}
buf.extend_from_slice(&chunk[..n]);
if buf.windows(4).any(|window| window == b"\r\n\r\n") {
break;
}
}
Ok(String::from_utf8_lossy(&buf).into_owned())
}
async fn spawn_popup_external_child_frame_server() -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind popup external child frame server");
let addr = listener
.local_addr()
.expect("popup external child frame server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener
.accept()
.await
.expect("accept popup external child frame request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read popup external child frame request");
let body = r#"<!doctype html>
<script>
window.onfocus = () => {
parent.opener.postMessage("child-window-focus", "*");
};
window.onblur = () => {
parent.opener.postMessage("child-window-blur", "*");
};
window.addEventListener("load", () => {
parent.opener.postMessage(
"external:" + (parent !== self) + "|" + (top === parent) + "|" + (typeof parent.opener.postMessage),
"*"
);
});
</script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write popup external child frame response");
});
(format!("http://{addr}/child.html"), server)
}
async fn spawn_csp_sandbox_storage_bucket_popup_server() -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind CSP sandbox popup test server");
let addr = listener
.local_addr()
.expect("CSP sandbox popup server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener
.accept()
.await
.expect("accept CSP sandbox popup request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read CSP sandbox popup request");
let body = r#"<!doctype html>
<script>
function post_message(data) {
if (window.parent !== null) {
window.parent.postMessage(data, { targetOrigin: "*" });
}
if (window.opener !== null) {
window.opener.postMessage(data, { targetOrigin: "*" });
}
}
navigator.storageBuckets.open("opaque-origin-bucket")
.then(() => post_message("navigator.storageBuckets.open(): FULFILLED"))
.catch(error => post_message("navigator.storageBuckets.open(): REJECTED: " + error.name));
navigator.storageBuckets.keys()
.then(() => post_message("navigator.storageBuckets.keys(): FULFILLED"))
.catch(error => post_message("navigator.storageBuckets.keys(): REJECTED: " + error.name));
navigator.storageBuckets.delete("opaque-origin-bucket")
.then(() => post_message("navigator.storageBuckets.delete(): FULFILLED"))
.catch(error => post_message("navigator.storageBuckets.delete(): REJECTED: " + error.name));
</script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Security-Policy: sandbox allow-scripts\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write CSP sandbox popup response");
});
(format!("http://{addr}/popup.html"), server)
}
async fn spawn_sandbox_popup_helper_server() -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind sandbox popup helper server");
let addr = listener
.local_addr()
.expect("sandbox popup helper server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
for _ in 0..2 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept sandbox popup helper request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read sandbox popup helper request");
let body = r#"<!doctype html>
<script>
if (opener) {
opener.postMessage(undefined, "*");
self.close();
} else {
onmessage = function (e) {
parent.postMessage({ data: e.data, origin: e.origin }, "*");
};
var popupWin = window.open();
popupWin.location.href = location.href;
}
</script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write sandbox popup helper response");
}
});
(
format!("http://{addr}/iframe_sandbox_popups_helper-3.html"),
server,
)
}
async fn spawn_sandbox_child_top_navigation_popup_server() -> (String, tokio::task::JoinHandle<()>)
{
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind sandbox child top navigation popup server");
let addr = listener
.local_addr()
.expect("sandbox child top navigation popup server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
for _ in 0..2 {
let (mut stream, _) = listener
.accept()
.await
.expect("accept sandbox child top navigation popup request");
let mut buffer = [0; 1024];
let n = stream
.read(&mut buffer)
.await
.expect("read sandbox child top navigation popup request");
let request = String::from_utf8_lossy(&buffer[..n]);
let body = if request.starts_with("GET /popup.html ") {
r#"<!doctype html>
<iframe sandbox="allow-scripts"></iframe>
<script>
onmessage = event => opener.postMessage(event.data, "*");
document.querySelector("iframe").src = "/child.html";
</script>"#
} else {
r#"<!doctype html>
<script>
onload = () => {
try {
top.location = "/navigated.html";
top.postMessage("can navigate", "*");
} catch (error) {
top.postMessage("cannot navigate", "*");
}
};
</script>"#
};
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write sandbox child top navigation popup response");
}
});
(format!("http://{addr}/popup.html"), server)
}
async fn spawn_lightweight_popup_response_csp_external_script_server()
-> (String, tokio::task::JoinHandle<bool>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind popup response external CSP test server");
let addr = listener
.local_addr()
.expect("popup response external CSP server addr");
let server = tokio::spawn(async move {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let (mut stream, _) = listener
.accept()
.await
.expect("accept popup response external CSP request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.await
.expect("read popup response external CSP request");
let body = r#"<!doctype html><script src="/blocked.js"></script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Security-Policy: script-src 'none'\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.await
.expect("write popup response external CSP response");
let Ok(Ok((mut script_stream, _))) =
tokio::time::timeout(std::time::Duration::from_millis(250), listener.accept()).await
else {
return false;
};
let _ = script_stream.read(&mut buffer).await;
let body = r#"opener.__popupResponseCspExternalEvents.push("script");"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let _ = script_stream.write_all(response.as_bytes()).await;
true
});
(format!("http://{addr}/popup.html"), server)
}
async fn spawn_lightweight_popup_response_csp_redirect_external_script_servers() -> (
String,
String,
std::thread::JoinHandle<()>,
std::thread::JoinHandle<()>,
) {
let target_listener =
std::net::TcpListener::bind("127.0.0.1:0").expect("bind popup redirect CSP target server");
let target_addr = target_listener
.local_addr()
.expect("popup redirect CSP target addr");
let final_script_url = format!("http://{target_addr}/final.js");
let final_script_url_for_source = final_script_url.clone();
let target_server = std::thread::spawn(move || {
use std::io::{Read, Write};
let mut stream = accept_popup_redirect_test_connection(&target_listener)
.expect("accept popup redirect CSP final script request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.expect("read popup redirect CSP final script request");
let body = r#"opener.__popupRedirectCspEvents.push("script");"#;
let response = format!(
"HTTP/1.1 200 OK\r\nAccess-Control-Allow-Origin: *\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.expect("write popup redirect CSP final script response");
});
let source_listener =
std::net::TcpListener::bind("127.0.0.1:0").expect("bind popup redirect CSP source server");
let source_addr = source_listener
.local_addr()
.expect("popup redirect CSP source addr");
let source_server = std::thread::spawn(move || {
use std::io::{Read, Write};
let mut stream = accept_popup_redirect_test_connection(&source_listener)
.expect("accept popup redirect CSP document request");
let mut buffer = [0; 1024];
let _ = stream
.read(&mut buffer)
.expect("read popup redirect CSP document request");
let body = r#"<!doctype html><script src="/redirect.js"></script>"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Security-Policy: script-src 'self'\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
stream
.write_all(response.as_bytes())
.expect("write popup redirect CSP document response");
let mut stream = accept_popup_redirect_test_connection(&source_listener)
.expect("accept popup redirect CSP script request");
let _ = stream
.read(&mut buffer)
.expect("read popup redirect CSP script request");
let response = format!(
"HTTP/1.1 302 Found\r\nLocation: {final_script_url_for_source}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
);
stream
.write_all(response.as_bytes())
.expect("write popup redirect CSP redirect response");
});
(
format!("http://{source_addr}/popup.html"),
final_script_url,
source_server,
target_server,
)
}
fn accept_popup_redirect_test_connection(
listener: &std::net::TcpListener,
) -> std::io::Result<std::net::TcpStream> {
listener.set_nonblocking(true)?;
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
loop {
match listener.accept() {
Ok((stream, _)) => {
// Accepted sockets can inherit O_NONBLOCK from the listener on
// some platforms. The request bytes are allowed to arrive
// after accept, so restore blocking I/O with a bounded timeout
// before the fixture reads the request head.
stream.set_nonblocking(false)?;
stream.set_read_timeout(Some(std::time::Duration::from_secs(5)))?;
stream.set_write_timeout(Some(std::time::Duration::from_secs(5)))?;
return Ok(stream);
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
if std::time::Instant::now() >= deadline {
return Err(std::io::Error::new(
std::io::ErrorKind::TimedOut,
"timed out waiting for popup redirect test connection",
));
}
std::thread::sleep(std::time::Duration::from_millis(5));
}
Err(error) => return Err(error),
}
}
}
mod extracted;