leyline-http 0.1.5

HTTP client that impersonates Chrome, Firefox, and Safari on the wire: TLS (JA3/JA4), HTTP/2, and HTTP/3 fingerprints
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

use crate::core::error::Result;
use crate::core::{Session, SessionIdentity};

use super::secret::ProxyKey;
use super::{Device, config};

impl Device {
    pub fn check(&self, session: &Session) -> Result<()> {
        let id = session.identity();
        let mut differences = match self.profile_id.as_deref() {
            Some(expected) => profile_difference(expected, &id),
            None => self.identity_differences(&id),
        };
        let profile_changed = !differences.is_empty();
        differences.extend(self.setting_differences(session, &id));
        differences.extend(self.strict_gaps());
        if differences.is_empty() {
            return Ok(());
        }
        let err = config(format!(
            "the session differs from the device: {}",
            differences.join("; ")
        ));
        Err(if profile_changed {
            err.with_source(crate::core::error::ProfileChanged)
        } else {
            err
        })
    }

    fn identity_differences(&self, id: &SessionIdentity) -> Vec<String> {
        let mut differences = Vec::new();
        if self.identity != id.to_identity() {
            differences.push(format!(
                "identity {:?} (device {:?})",
                id.to_identity(),
                self.identity
            ));
        }
        if self.platform != id.platform() {
            differences.push(format!(
                "platform {:?} (device {:?})",
                id.platform(),
                self.platform
            ));
        }
        if self.brand != id.brand() {
            differences.push(format!("brand {:?} (device {:?})", id.brand(), self.brand));
        }
        if let Some(expected) = self.user_agent.as_deref()
            && expected != id.user_agent()
        {
            differences.push(format!(
                "user_agent {:?} (device {expected:?})",
                id.user_agent()
            ));
        }
        differences
    }

    fn strict_gaps(&self) -> Vec<String> {
        let mut gaps = Vec::new();
        if !self.strict {
            return gaps;
        }
        if self.profile_id.is_none() {
            gaps.push("strict device has no profile_id".to_owned());
        }
        if self.proxy.is_none() && !self.env_proxy {
            gaps.push("strict device has no proxy and env_proxy is false".to_owned());
        }
        gaps
    }

    fn setting_differences(&self, session: &Session, id: &SessionIdentity) -> Vec<String> {
        let mut differences = Vec::new();
        if self.languages.as_deref() != id.languages() {
            differences.push(format!(
                "languages {:?} (device {:?})",
                id.languages(),
                self.languages
            ));
        }
        let proxy = session.proxy_url();
        if !self.env_proxy
            && self.proxy.as_ref().map(ProxyKey::of) != proxy.as_ref().map(ProxyKey::of)
        {
            differences.push(format!("proxy {proxy:?} (device {:?})", self.proxy));
        }
        differences
    }
}

fn profile_difference(expected: &str, id: &SessionIdentity) -> Vec<String> {
    match id.profile_id() {
        Some(actual) if actual == expected => Vec::new(),
        actual => vec![format!("profile_id {actual:?} (device {expected:?})")],
    }
}