rustenium-identity 0.1.0

A versatile stealth overlay for rustenium
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

pub mod identity;
pub mod ua;
pub mod tz;
pub mod error;
pub mod cdp;
pub mod script;
pub mod preset;

use error::IdentityError;
use rustenium::browsers::chrome::browser::{ChromeBrowser, ChromeConfig};
use rustenium::browsers::cdp_browser::CdpBrowser;

pub use identity::*;
pub use error::IdentityError as Error;

/// Configuration for launching an identity-spoofed browser session.
pub struct IdentityConfig {
    pub identity: Identity,
    pub chrome: ChromeConfig,
}

impl From<Identity> for IdentityConfig {
    fn from(identity: Identity) -> Self {
        Self {
            identity,
            chrome: ChromeConfig {
                enable_bidi: false,
                enable_cdp: true,
                ..Default::default()
            },
        }
    }
}

impl IdentityConfig {
    pub fn new(identity: Identity, chrome: ChromeConfig) -> Self {
        Self { identity, chrome }
    }
}

/// A rustenium browser session with an identity applied.
pub struct IdentitySession {
    identity: Identity,
    browser: ChromeBrowser,
}

impl IdentitySession {
    /// Launch a new Chromium instance from the given config.
    /// Applies all CDP emulation overrides and registers the stealth
    /// bootstrap script before returning.
    pub async fn launch(config: impl Into<IdentityConfig>) -> Result<Self, IdentityError> {
        let config = config.into();
        let timezone = tz::resolve_timezone(
            config.identity.timezone.as_deref(),
            config.identity.proxy.as_deref(),
        )
        .await?;

        let mut chrome_config = config.chrome;

        // Disable BiDi
        chrome_config.enable_bidi = false;
        // Ensure CDP is enabled
        chrome_config.enable_cdp = true;

        // Add proxy flag if set on identity
        if let Some(ref proxy) = config.identity.proxy {
            if !proxy.is_empty() {
                let mut flags = chrome_config.browser_flags.unwrap_or_default();
                flags.push(format!("--proxy-server={}", proxy));
                chrome_config.browser_flags = Some(flags);
            }
        }

        let mut browser = ChromeBrowser::new(chrome_config).await;

        cdp::apply_identity(&mut browser, &config.identity, &timezone).await?;

        Ok(Self {
            identity: config.identity,
            browser,
        })
    }

    /// Access the underlying rustenium ChromeBrowser.
    pub fn browser(&self) -> &ChromeBrowser {
        &self.browser
    }

    /// Mutable access to the underlying rustenium ChromeBrowser.
    pub fn browser_mut(&mut self) -> &mut ChromeBrowser {
        &mut self.browser
    }

    /// Get the identity.
    pub fn identity(&self) -> &Identity {
        &self.identity
    }
}