use std::borrow::Cow;
use std::fmt;
use chromiumoxide::browser::BrowserConfigBuilder;
use chromiumoxide::cdp::browser_protocol::browser::BrowserContextId;
use chromiumoxide::cdp::CustomEvent;
use chromiumoxide::error::CdpError;
use chromiumoxide::types::{MethodId, MethodType};
use chromiumoxide::{Browser, Command, Method, Page};
use serde::{Deserialize, Serialize, Serializer};
use serde_json::Value;
use crate::captcha::{
CaptchaEvent, SolveMethod, CAPTCHA_DETECTED, CAPTCHA_FAILED, CAPTCHA_SOLVED, CAPTCHA_SOLVING,
DISABLE_METHOD, ENABLE_METHOD, SOLVER_EVAL_METHOD, SOLVER_EVAL_RESULT,
};
use crate::core::{Error, IntoProxySpec, CREATE_CONTEXT_METHOD, CREDENTIALS_METHOD};
use crate::launch::{is_suppressed_default_arg, LAUNCH_ARGS};
use crate::registration::{proxy_registration, ConnKey};
#[derive(Debug)]
pub enum OxideError {
Chromeleon(Error),
Cdp(CdpError),
}
impl fmt::Display for OxideError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
OxideError::Chromeleon(e) => write!(f, "{e}"),
OxideError::Cdp(e) => write!(f, "{e}"),
}
}
}
impl std::error::Error for OxideError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
OxideError::Chromeleon(e) => Some(e),
OxideError::Cdp(e) => Some(e),
}
}
}
impl From<Error> for OxideError {
fn from(e: Error) -> Self {
OxideError::Chromeleon(e)
}
}
impl From<CdpError> for OxideError {
fn from(e: CdpError) -> Self {
OxideError::Cdp(e)
}
}
#[derive(Debug, Clone)]
pub struct RawCommand {
pub method: Cow<'static, str>,
pub params: Value,
}
impl RawCommand {
pub fn new(method: impl Into<Cow<'static, str>>, params: Value) -> Self {
RawCommand {
method: method.into(),
params,
}
}
}
impl Serialize for RawCommand {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.params.serialize(serializer)
}
}
impl Method for RawCommand {
fn identifier(&self) -> MethodId {
self.method.clone()
}
}
impl Command for RawCommand {
type Response = Value;
}
pub async fn send_raw(
browser: &Browser,
method: impl Into<Cow<'static, str>>,
params: Value,
) -> Result<Value, OxideError> {
Ok(browser
.execute(RawCommand::new(method, params))
.await?
.result)
}
pub async fn send_raw_page(
page: &Page,
method: impl Into<Cow<'static, str>>,
params: Value,
) -> Result<Value, OxideError> {
Ok(page.execute(RawCommand::new(method, params)).await?.result)
}
pub async fn new_proxy_context(
browser: &Browser,
proxy: impl IntoProxySpec,
) -> Result<BrowserContextId, OxideError> {
new_proxy_context_inner(browser, proxy, None).await
}
pub async fn new_proxy_context_with_id(
browser: &Browser,
proxy: impl IntoProxySpec,
credentials_id: &str,
) -> Result<BrowserContextId, OxideError> {
new_proxy_context_inner(browser, proxy, Some(credentials_id)).await
}
async fn new_proxy_context_inner(
browser: &Browser,
proxy: impl IntoProxySpec,
credentials_id: Option<&str>,
) -> Result<BrowserContextId, OxideError> {
let conn = ConnKey::new(browser.websocket_address().clone());
let registration = proxy_registration(conn, proxy).await?;
let mut credentials = registration.credentials_params();
if let Some(id) = credentials_id {
credentials = credentials.with_credentials_id(id);
}
send_raw(browser, CREDENTIALS_METHOD, credentials.to_value()).await?;
let mut context_params = registration.create_context_params();
if let Some(id) = credentials_id {
context_params = context_params.with_credentials_id(id);
}
let created = send_raw(browser, CREATE_CONTEXT_METHOD, context_params.to_value()).await?;
drop(registration);
match created["browserContextId"].as_str() {
Some(id) => Ok(BrowserContextId::from(id.to_string())),
None => Err(OxideError::Chromeleon(Error::RegistrationRefused {
detail: format!("createBrowserContext returned no browserContextId: {created}"),
})),
}
}
pub fn kept_default_args() -> Vec<String> {
CHROMIUMOXIDE_DEFAULT_ARGS
.iter()
.filter(|arg| !is_suppressed_default_arg(arg))
.filter(|arg| {
!matches!(
**arg,
"--enable-automation" | "--lang=en_US" | "--enable-blink-features=IdleDetection"
)
})
.map(|arg| arg.to_string())
.collect()
}
const CHROMIUMOXIDE_DEFAULT_ARGS: &[&str] = &[
"--disable-background-networking",
"--enable-features=NetworkService,NetworkServiceInProcess",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
"--disable-breakpad",
"--disable-client-side-phishing-detection",
"--disable-component-extensions-with-background-pages",
"--disable-default-apps",
"--disable-dev-shm-usage",
"--disable-features=TranslateUI",
"--disable-hang-monitor",
"--disable-ipc-flooding-protection",
"--disable-popup-blocking",
"--disable-prompt-on-repost",
"--disable-renderer-backgrounding",
"--disable-sync",
"--force-color-profile=srgb",
"--metrics-recording-only",
"--no-first-run",
"--enable-automation",
"--password-store=basic",
"--use-mock-keychain",
"--enable-blink-features=IdleDetection",
"--lang=en_US",
];
pub fn browser_config(executable: impl AsRef<std::path::Path>) -> BrowserConfigBuilder {
chromiumoxide::BrowserConfig::builder()
.chrome_executable(executable.as_ref())
.disable_default_args()
.args(kept_default_args())
.args(LAUNCH_ARGS.iter().map(|a| a.to_string()))
}
pub async fn enable_captcha(page: &Page) -> Result<Value, OxideError> {
send_raw_page(page, ENABLE_METHOD, serde_json::json!({})).await
}
pub async fn disable_captcha(page: &Page) -> Result<Value, OxideError> {
send_raw_page(page, DISABLE_METHOD, serde_json::json!({})).await
}
pub async fn solver_eval(
page: &Page,
expression: &str,
frame_url_contains: &str,
) -> Result<Value, OxideError> {
send_raw_page(
page,
SOLVER_EVAL_METHOD,
crate::captcha::solver_eval_params(expression, frame_url_contains).to_value(),
)
.await
}
macro_rules! chromeleon_event {
($name:ident, $method:expr, $doc:expr) => {
#[doc = $doc]
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct $name {
/// The sitekey, or the embedder host for the hCaptcha-checkbox,
#[serde(default)]
pub sitekey: String,
#[serde(default)]
pub method: Option<SolveMethod>,
#[serde(default)]
pub attempts: u32,
#[serde(default)]
pub time_ms: f64,
#[serde(default)]
pub reason: String,
}
impl MethodType for $name {
fn method_id() -> MethodId {
$method.into()
}
}
impl CustomEvent for $name {}
impl $name {
pub fn to_event(&self) -> Option<CaptchaEvent> {
CaptchaEvent::parse($method, &serde_json::to_value(self.as_params()).ok()?)
}
fn as_params(&self) -> Value {
serde_json::json!({
"sitekey": self.sitekey,
"method": self.method,
"attempts": self.attempts,
"timeMs": self.time_ms,
"reason": self.reason,
})
}
}
};
}
chromeleon_event!(
CaptchaDetectedEvent,
CAPTCHA_DETECTED,
"`Chromeleon.captchaDetected`: a challenge was found."
);
chromeleon_event!(
CaptchaSolvingEvent,
CAPTCHA_SOLVING,
"`Chromeleon.captchaSolving`: a solve started."
);
chromeleon_event!(
CaptchaSolvedEvent,
CAPTCHA_SOLVED,
"`Chromeleon.captchaSolved`: a solve finished and the token was written."
);
chromeleon_event!(
CaptchaFailedEvent,
CAPTCHA_FAILED,
"`Chromeleon.captchaFailed`: a solve gave up."
);
#[derive(Debug, Clone, Deserialize)]
pub struct SolverEvalResultEvent {
#[serde(default)]
pub result: String,
}
impl MethodType for SolverEvalResultEvent {
fn method_id() -> MethodId {
SOLVER_EVAL_RESULT.into()
}
}
impl CustomEvent for SolverEvalResultEvent {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_raw_command_serializes_to_its_params_and_carries_its_method() {
let cmd = RawCommand::new(
CREDENTIALS_METHOD,
serde_json::json!({"proxyServer": "http://gw:1"}),
);
assert_eq!(cmd.identifier().as_ref(), "Target.setProxyCredentials");
assert_eq!(
serde_json::to_value(&cmd).unwrap(),
serde_json::json!({"proxyServer": "http://gw:1"})
);
}
#[test]
fn curated_defaults_drop_the_tells() {
let kept = kept_default_args();
for gone in [
"--enable-automation",
"--lang=en_US",
"--use-mock-keychain",
"--metrics-recording-only",
"--disable-breakpad",
] {
assert!(!kept.iter().any(|a| a == gone), "{gone} survived");
}
for kept_arg in [
"--disable-dev-shm-usage",
"--no-first-run",
"--disable-sync",
] {
assert!(kept.iter().any(|a| a == kept_arg), "{kept_arg} was dropped");
}
}
#[test]
fn the_documented_overlap_with_our_suppression_list_is_the_real_one() {
use crate::launch::SUPPRESSED_DEFAULT_ARGS;
let overlap: Vec<&str> = CHROMIUMOXIDE_DEFAULT_ARGS
.iter()
.copied()
.filter(|a| crate::launch::is_suppressed_default_arg(a))
.collect();
assert_eq!(overlap.len(), 6, "overlap changed: {overlap:?}");
assert!(SUPPRESSED_DEFAULT_ARGS.contains(&"--disable-extensions"));
assert!(!overlap.contains(&"--disable-extensions"));
}
#[test]
fn events_convert_to_the_driver_agnostic_form() {
let solved = CaptchaSolvedEvent {
sitekey: "abc".into(),
method: None,
attempts: 2,
time_ms: 12.0,
reason: String::new(),
};
assert_eq!(
solved.to_event(),
Some(CaptchaEvent::Solved {
sitekey: "abc".into(),
attempts: 2,
time_ms: 12.0
})
);
}
}