use std::collections::BTreeMap;
use std::ffi::OsString;
use std::io::{BufRead, BufReader, Read, Write};
use std::net::TcpStream;
use std::path::{Path, PathBuf};
use std::process::{Child, Command, Stdio};
use std::time::{Duration, Instant};
pub const LAUNCH_ARGS: &[&str] = &["--webrtc-ip-handling-policy=disable_non_proxied_udp"];
pub const SUPPRESSED_DEFAULT_ARGS: &[&str] = &[
"--disable-field-trial-config",
"--disable-component-update",
"--disable-client-side-phishing-detection",
"--metrics-recording-only",
"--disable-breakpad",
"--no-service-autorun",
"--disable-extensions",
"--disable-default-apps",
"--disable-component-extensions-with-background-pages",
"--disable-search-engine-choice-screen",
"--no-default-browser-check",
"--unsafely-disable-devtools-self-xss-warnings",
"--use-mock-keychain",
];
pub fn is_suppressed_default_arg(arg: &str) -> bool {
let name = switch_name(arg);
SUPPRESSED_DEFAULT_ARGS
.iter()
.any(|s| switch_name(s) == name)
}
pub fn without_suppressed_defaults<'a, I>(defaults: I) -> Vec<String>
where
I: IntoIterator,
I::Item: AsRef<str> + 'a,
{
defaults
.into_iter()
.filter(|a| !is_suppressed_default_arg(a.as_ref()))
.map(|a| a.as_ref().to_string())
.collect()
}
fn switch_name(arg: &str) -> &str {
match arg.find('=') {
Some(i) => &arg[..i],
None => arg,
}
}
pub fn merge_launch_args<A, E>(args: A, extra: E) -> Vec<String>
where
A: IntoIterator,
A::Item: AsRef<str>,
E: IntoIterator,
E::Item: AsRef<str>,
{
let mut merged: Vec<String> = args.into_iter().map(|a| a.as_ref().to_string()).collect();
for flag in extra {
let flag = flag.as_ref();
if !merged.iter().any(|a| switch_name(a) == switch_name(flag)) {
merged.push(flag.to_string());
}
}
merged
}
pub fn launch_args<A>(args: A, captcha: bool, captcha_model_path: Option<&str>) -> Vec<String>
where
A: IntoIterator,
A::Item: AsRef<str>,
{
let mut extra: Vec<String> = LAUNCH_ARGS.iter().map(|s| s.to_string()).collect();
if captcha || captcha_model_path.is_some() {
extra.extend(crate::captcha::captcha_launch_args(captcha_model_path));
}
merge_launch_args(args, extra)
}
pub fn browser_process_env() -> BTreeMap<String, String> {
filter_proxy_env(
std::env::vars_os()
.filter_map(|(k, v)| Some((k.into_string().ok()?, v.into_string().ok()?))),
)
}
pub fn filter_proxy_env<I, K, V>(env: I) -> BTreeMap<String, String>
where
I: IntoIterator<Item = (K, V)>,
K: Into<String>,
V: Into<String>,
{
env.into_iter()
.map(|(k, v)| (k.into(), v.into()))
.filter(|(k, _)| !k.to_uppercase().contains("PROXY"))
.collect()
}
#[derive(Debug, Clone)]
pub struct Launcher {
executable: PathBuf,
args: Vec<String>,
env_overrides: BTreeMap<String, String>,
inherit_env: bool,
captcha: bool,
captcha_model_path: Option<String>,
page_settle: Option<crate::settle::SettleTuning>,
debugging_port: Option<u16>,
}
impl Launcher {
pub fn new(executable: impl AsRef<Path>) -> Self {
Launcher {
executable: executable.as_ref().to_path_buf(),
args: Vec::new(),
env_overrides: BTreeMap::new(),
inherit_env: true,
captcha: false,
captcha_model_path: None,
page_settle: None,
debugging_port: None,
}
}
pub fn arg(mut self, arg: impl Into<String>) -> Self {
self.args.push(arg.into());
self
}
pub fn args<I>(mut self, args: I) -> Self
where
I: IntoIterator,
I::Item: Into<String>,
{
self.args.extend(args.into_iter().map(Into::into));
self
}
pub fn remote_debugging_port(mut self, port: u16) -> Self {
self.debugging_port = Some(port);
self.arg(format!("--remote-debugging-port={port}"))
}
pub fn user_data_dir(self, dir: impl AsRef<Path>) -> Self {
self.arg(format!("--user-data-dir={}", dir.as_ref().display()))
}
pub fn fingerprint_os(self, os: impl Into<String>) -> Self {
self.arg(format!("--fingerprint-os={}", os.into()))
}
pub fn fingerprint_seed(self, seed: u64) -> Self {
self.arg(format!("--fingerprint-seed={seed}"))
}
pub fn config_file(self, path: impl AsRef<Path>) -> Self {
self.arg(format!("--cr-cfg-file={}", path.as_ref().display()))
}
pub fn captcha(mut self, on: bool) -> Self {
self.captcha = on;
self
}
pub fn captcha_model_path(mut self, dir: impl Into<String>) -> Self {
self.captcha_model_path = Some(dir.into());
self
}
pub fn page_settle(mut self, on: bool) -> Self {
self.page_settle = on.then(|| self.page_settle.unwrap_or_default());
self
}
pub fn page_settle_tuning(mut self, tuning: crate::settle::SettleTuning) -> Self {
self.page_settle = Some(tuning);
self
}
pub fn env(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.env_overrides.insert(key.into(), value.into());
self
}
pub fn envs<I, K, V>(mut self, env: I) -> Self
where
I: IntoIterator<Item = (K, V)>,
K: Into<String>,
V: Into<String>,
{
self.env_overrides
.extend(env.into_iter().map(|(k, v)| (k.into(), v.into())));
self
}
pub fn clear_env(mut self) -> Self {
self.inherit_env = false;
self
}
pub fn build_args(&self) -> Vec<String> {
let args = launch_args(
self.args.iter().map(String::as_str),
self.captcha,
self.captcha_model_path.as_deref(),
);
match self.page_settle {
Some(tuning) => merge_launch_args(args, crate::settle::settle_launch_args(tuning)),
None => args,
}
}
pub fn build_env(&self) -> BTreeMap<String, String> {
let mut env = if self.inherit_env {
browser_process_env()
} else {
BTreeMap::new()
};
env.extend(filter_proxy_env(self.env_overrides.clone()));
env
}
pub fn command(&self) -> Command {
let mut cmd = Command::new(&self.executable);
cmd.args(self.build_args());
cmd.env_clear();
for (k, v) in self.build_env() {
cmd.env(OsString::from(k), OsString::from(v));
}
cmd
}
pub fn spawn(&self) -> std::io::Result<Child> {
self.command().spawn()
}
pub fn spawn_quiet(&self) -> std::io::Result<Child> {
self.command()
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
}
pub fn spawn_and_wait(&self, timeout: Duration) -> std::io::Result<(Child, String)> {
let port = self.debugging_port.ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"spawn_and_wait needs remote_debugging_port(...) — with no port there is \
nothing to wait for",
)
})?;
let mut child = self.spawn_quiet()?;
match devtools_url(port, timeout) {
Ok(url) => Ok((child, url)),
Err(e) => {
let _ = child.kill();
let _ = child.wait();
Err(e)
}
}
}
}
pub fn devtools_url(port: u16, timeout: Duration) -> std::io::Result<String> {
let deadline = Instant::now() + timeout;
let mut last = String::from("never connected");
while Instant::now() < deadline {
match json_version(port) {
Ok(body) => match serde_json::from_str::<serde_json::Value>(&body) {
Ok(parsed) => match parsed["webSocketDebuggerUrl"].as_str() {
Some(url) => return Ok(url.to_string()),
None => last = format!("no webSocketDebuggerUrl in {body}"),
},
Err(e) => last = format!("unparseable /json/version: {e}"),
},
Err(e) => last = e.to_string(),
}
std::thread::sleep(Duration::from_millis(100));
}
Err(std::io::Error::new(
std::io::ErrorKind::TimedOut,
format!("browser never exposed CDP on 127.0.0.1:{port} ({last})"),
))
}
fn json_version(port: u16) -> std::io::Result<String> {
let stream = TcpStream::connect(("127.0.0.1", port))?;
stream.set_read_timeout(Some(Duration::from_secs(5)))?;
let mut writer = &stream;
write!(
writer,
"GET /json/version HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n"
)?;
let mut reader = BufReader::new(&stream);
let mut line = String::new();
let mut content_length: Option<usize> = None;
loop {
line.clear();
if reader.read_line(&mut line)? == 0 {
return Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"connection closed before the body",
));
}
if line.trim().is_empty() {
break; }
if let Some(value) = line
.split_once(':')
.filter(|(name, _)| name.eq_ignore_ascii_case("content-length"))
.map(|(_, value)| value.trim())
{
content_length = value.parse().ok();
}
}
match content_length {
Some(len) => {
let mut body = vec![0u8; len];
reader.read_exact(&mut body)?;
String::from_utf8(body)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
None => {
let mut body = Vec::new();
match reader.read_to_end(&mut body) {
Ok(_) => {}
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {}
Err(e) if e.kind() == std::io::ErrorKind::TimedOut => {}
Err(e) => return Err(e),
}
if body.is_empty() {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"no JSON body in /json/version",
));
}
String::from_utf8(body)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_caller_keeps_their_own_webrtc_policy() {
let args = launch_args(["--webrtc-ip-handling-policy=default"], false, None);
assert_eq!(args, ["--webrtc-ip-handling-policy=default"]);
}
#[test]
fn captcha_flags_are_added_only_when_asked() {
assert_eq!(launch_args::<[&str; 0]>([], false, None).len(), 1);
let on = launch_args::<[&str; 0]>([], true, None);
assert!(on.contains(&"--captcha-solver".to_string()));
let with_models = launch_args::<[&str; 0]>([], false, Some("/models"));
assert!(with_models.contains(&"--captcha-solver".to_string()));
assert!(with_models.contains(&"--captcha-model-path=/models".to_string()));
}
#[test]
fn proxy_variables_never_reach_the_browser() {
let env = filter_proxy_env([
("HTTP_PROXY", "http://controller:3128"),
("https_proxy", "http://controller:3128"),
("PROXY_USER", "u"),
("PATH", "/usr/bin"),
("CHROMELEON_EXIT_IP", "1.2.3.4"),
]);
assert_eq!(
env.keys().cloned().collect::<Vec<_>>(),
["CHROMELEON_EXIT_IP", "PATH"]
);
}
#[test]
fn persona_flags_land_on_the_command_line() {
let args = Launcher::new("/opt/chromeleon/chrome")
.fingerprint_os("Linux")
.fingerprint_seed(42)
.build_args();
assert!(args.contains(&"--fingerprint-os=Linux".to_string()));
assert!(args.contains(&"--fingerprint-seed=42".to_string()));
}
#[test]
fn page_settle_is_opt_in_and_never_a_default() {
use crate::settle::SettleTuning;
assert!(!LAUNCH_ARGS.contains(&"--page-settle"));
assert!(!launch_args::<[&str; 0]>([], false, None)
.iter()
.any(|a| a.starts_with("--page-settle")));
assert!(!Launcher::new("/x")
.build_args()
.iter()
.any(|a| a.starts_with("--page-settle")));
let tuned = Launcher::new("/x")
.page_settle_tuning(
SettleTuning::new()
.quiet_window_ms(1500)
.min_chars(64)
.timeout_ms(20_000)
.sample_interval_ms(100)
.pierce_shadow(true),
)
.build_args();
for expected in [
"--page-settle",
"--page-settle-quiet-window-ms=1500",
"--page-settle-min-chars=64",
"--page-settle-timeout-ms=20000",
"--page-settle-sample-interval-ms=100",
"--page-settle-pierce-shadow",
] {
assert!(
tuned.contains(&expected.to_string()),
"{expected} missing: {tuned:?}"
);
}
let by_hand = Launcher::new("/x")
.arg("--page-settle-quiet-window-ms=250")
.page_settle_tuning(SettleTuning::new().quiet_window_ms(1500))
.build_args();
assert!(by_hand.contains(&"--page-settle-quiet-window-ms=250".to_string()));
assert_eq!(
by_hand
.iter()
.filter(|a| a.starts_with("--page-settle-quiet-window-ms"))
.count(),
1
);
assert!(!Launcher::new("/x")
.page_settle(true)
.page_settle(false)
.build_args()
.iter()
.any(|a| a.starts_with("--page-settle")));
}
#[test]
fn suppressed_defaults_are_matched_by_switch_name() {
assert!(is_suppressed_default_arg("--disable-extensions"));
assert!(is_suppressed_default_arg("--metrics-recording-only=1"));
assert!(!is_suppressed_default_arg("--headless=new"));
let kept = without_suppressed_defaults(["--headless=new", "--disable-breakpad"]);
assert_eq!(kept, ["--headless=new"]);
}
}