d0rb/rusttlsx🦀 Stealth-HTTP-Client für Rust. Imitiert echte Browser-TLS-Fingerprints für unerkennbare Anfragen. Schnell, typsicher und für präzises Networking entwickelt.
. Ein fortschrittlicher Stealth-HTTP-Client für Rust.
Entwickelt für datenschutzbewusste Entwickler, die volle Kontrolle über ihren Netzwerk-Fingerprint benötigen.
Sieht aus wie ein Browser. Verhält sich wie ein Browser. Geschrieben in Rust.
Basiert auf bogdanfinn/tls-client – der branchenführenden TLS-Fingerprinting-Bibliothek, der Sicherheitsexperten weltweit vertrauen. Wir nutzen bogdanfinns kampferprobte Shared Libraries (.dll/.so/.dylib) über FFI-Bindungen, weil:
RustTLSX bringt diese bewährte Technologie mit einer typsicheren, ergonomischen API in die Rust-Welt, die 6x schneller ist als Python-Alternativen.
Moderne Webanwendungen analysieren jeden Aspekt deiner HTTP-Anfragen – nicht nur Header und Cookies, sondern auch die tiefen kryptografischen Signaturen deines TLS-Handshakes. Standard-Rust-HTTP-Clients (reqwest, hyper, ureq) erzeugen leicht erkennbare Muster, die automatisierten Traffic sofort identifizieren.
RustTLSX löst dies, indem es Folgendes bietet:
Lade die erforderliche TLS-Client-Bibliothek für deine Plattform von den tls-client-Releases herunter:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibLege die Bibliotheksdatei in deinem Projektstammverzeichnis, im Systembibliothekspfad (/usr/local/lib/) ab oder stelle sicher, dass sie über PATH erreichbar ist.
Füge RustTLSX zu deiner Cargo.toml hinzu:
[dependencies]
rust-tlsx = "0.1"
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
let client = TlsClient::new(BrowserProfile::Firefox120)
.header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0")
.timeout(30);
let response = client.get("https://example.com")?;
println!("Status: {}", response.status);
println!("Body: {}", response.body);
Ok(())
}
RustTLSX unterstützt über 30 Browser-Profile gängiger Browser:
// Chrome versions
BrowserProfile::Chrome103
BrowserProfile::Chrome107
BrowserProfile::Chrome109
BrowserProfile::Chrome120
// Firefox versions
BrowserProfile::Firefox102
BrowserProfile::Firefox105
BrowserProfile::Firefox108
BrowserProfile::Firefox120
// Safari versions
BrowserProfile::Safari15_6_1
BrowserProfile::Safari16_0
BrowserProfile::SafariIos16_0
// Opera and others
BrowserProfile::Opera89
BrowserProfile::Opera90
let client = TlsClient::new(BrowserProfile::Chrome109)
.header("Accept", "application/json")
.header("Accept-Language", "en-US,en;q=0.9")
.cookie("session", "abc123")
.cookie("token", "xyz789");
let response = client.get("https://api.example.com")?;
let body = r#"{"username": "user", "password": "pass"}"#;
let response = client.post("https://example.com/login", Some(body.to_string()))?;
let client = TlsClient::new(BrowserProfile::Firefox120)
.timeout(60); // seconds
let response = client.get("https://slow-api.example.com")?;
RustTLSX basiert auf einer Grundlage bewährter Exzellenz, statt das Rad neu zu erfinden. Wir verwenden bogdanfinns kompilierte Bibliotheken (.dll/.so/.dylib) über FFI, weil:
Forschungsinvestition: Bogdanfinn hat Tausende Stunden in das Reverse-Engineering des Browser-TLS-Verhaltens investiert. Diese Forschung zu reproduzieren würde Jahre dauern und wahrscheinlich schlechtere Ergebnisse liefern.
Kampferprobte Zuverlässigkeit: Diese Bibliotheken werden weltweit von großen Sicherheitsfirmen, Datenschutz-Tools und Forschungseinrichtungen eingesetzt. Sie wurden gegen jedes große Schutzsystem getestet.
Kontinuierliche Weiterentwicklung: Browser-Fingerprints ändern sich ständig. Bogdanfinns Bibliotheken erhalten regelmäßige Updates, um neuen Browserversionen und Schutzsystem-Updates zu entsprechen.
Leistungsoptimierung: Die native C/Go-Implementierung ist stark auf Geschwindigkeit und Speichereffizienz optimiert und liefert eine Leistung, die reine Rust-Implementierungen nicht erreichen können.
Dynamisches Laden zur Laufzeit: Bibliotheken werden bei Bedarf über FFI geladen, wodurch die Komplexität des statischen Linkens entfällt und die Leistung erhalten bleibt.
Speicherverwaltung: Rusts Ownership-Modell gewährleistet eine sichere Interaktion mit nativen Bibliotheken und verhindert Speicherlecks sowie Use-after-Free-Bugs, die in C/C++-Implementierungen häufig vorkommen.
Fehlerbehandlung: Umfassende, auf Result basierende Fehlerbehandlung liefert detaillierte Diagnosen bei gleichzeitiger Typsicherheit.
Verbindungsverwaltung: Intelligentes Pooling und Wiederverwendung von TLS-Verbindungen mit browser-genauen Verhaltensmustern.
Die zugrunde liegenden Bibliotheken verwalten jeden Aspekt des Browser-TLS-Verhaltens:
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
let client = TlsClient::new(BrowserProfile::Chrome109);
let response = client.get("https://httpbin.org/get")?;
println!("Status: {}", response.status);
println!("Body: {}", response.body);
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
let client = TlsClient::new(BrowserProfile::Firefox120);
let response = client.get("https://tls.peet.ws/api/all")?;
println!("TLS Fingerprint Analysis:\n{}", response.body);
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
let client = TlsClient::new(BrowserProfile::Chrome109)
.header("Authorization", "Bearer YOUR_TOKEN")
.header("Content-Type", "application/json");
let response = client.get("https://api.example.com/data")?;
match response.status {
200 => println!("Success: {}", response.body),
401 => eprintln!("Authentication failed"),
_ => eprintln!("Request failed with status {}: {}", response.status, response.body),
}
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
// Create a client that appears as a real Firefox browser
let client = TlsClient::new(BrowserProfile::Firefox120)
.header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0")
.header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
.header("Accept-Language", "en-US,en;q=0.5")
.header("Accept-Encoding", "gzip, deflate, br")
.header("DNT", "1") // Privacy-focused: Do Not Track
.timeout(30);
// Include session cookies for authenticated requests
let client = client.cookie("session_id", "your_session_token");
let response = client.get("https://example-site.com/data")?;
match response.status {
200 => println!("Data retrieved successfully with browser-like privacy"),
403 => println!("Authentication required - check session cookies"),
_ => println!("Response: {}", response.status),
}
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
use std::collections::HashMap;
fn main() -> anyhow::Result<()> {
// Simulate a specific browser environment
let mut headers = HashMap::new();
headers.insert("User-Agent".to_string(),
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36".to_string());
headers.insert("Sec-Fetch-Site".to_string(), "same-origin".to_string());
headers.insert("Sec-Fetch-Mode".to_string(), "navigate".to_string());
headers.insert("Sec-Fetch-Dest".to_string(), "document".to_string());
let client = TlsClient::new(BrowserProfile::Chrome120)
.headers(headers)
.timeout(45);
// Make request that's indistinguishable from real browser
let response = client.get("https://api.example.com/sensitive-data")?;
println!("Retrieved data with perfect browser mimicry");
println!("Protocol used: {}", response.used_protocol);
Ok(())
}
RustTLSX bietet allen Standard-Rust-HTTP-Clients überlegene Leistung und Datenschutz:
Zero-Copy-Operationen: Direkte FFI-Aufrufe an optimierte C/Go-Bibliotheken eliminieren unnötiges Datenkopieren, das reine Rust-Implementierungen plagt.
Connection-Pooling: Intelligente Wiederverwendung von TLS-Verbindungen mit browser-genauem Keep-Alive-Verhalten reduziert den Handshake-Overhead um bis zu 80 %.
Speichereffizienz: Rusts Ownership-Modell kombiniert mit optimierten nativen Bibliotheken führt zu 40 % geringerem Speicherverbrauch als vergleichbare Python-Lösungen.
Parallele Leistung: Nativer Async-Support mit korrektem Verbindungs-Multiplexing skaliert linear mit den CPU-Kernen.
Gegenüber Python-tls-client-Bindings:
Gegenüber Go-tls-client:
Gegenüber Node.js-Lösungen:
Lade die passende Binärdatei von den tls-client-Releases herunter:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibLege die Bibliotheksdatei in deinem Projektstammverzeichnis, im Systembibliotheksverzeichnis ab oder stelle sicher, dass sie über PATH erreichbar ist.
[dependencies]
rust-tlsx = "0.1"
anyhow = "1.0"
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
let client = TlsClient::new(BrowserProfile::Firefox120);
let response = client.get("https://example.com")?;
println!("Status: {}", response.status);
Ok(())
}
Die Haupt-Client-Schnittstelle für HTTP-Anfragen mit browserähnlichen TLS-Fingerprints.
impl TlsClient {
pub fn new(profile: BrowserProfile) -> Self
pub fn header(self, key: &str, value: &str) -> Self
pub fn headers(self, headers: HashMap<String, String>) -> Self
pub fn cookie(self, name: &str, value: &str) -> Self
pub fn cookies(self, cookies: Vec<CookieInput>) -> Self
pub fn timeout(self, seconds: i32) -> Self
pub fn get(&self, url: &str) -> Result<Response>
pub fn post(&self, url: &str, body: Option<String>) -> Result<Response>
}
Aufzählung der verfügbaren Browser-Fingerprint-Profile:
pub enum BrowserProfile {
// Chrome versions
Chrome103, Chrome104, Chrome105, Chrome106,
Chrome107, Chrome108, Chrome109, Chrome120,
// Firefox versions
Firefox102, Firefox104, Firefox105, Firefox106,
Firefox108, Firefox120,
// Safari versions
Safari15_6_1, Safari16_0,
SafariIpad15_6, SafariIos15_5, SafariIos15_6, SafariIos16_0,
// Opera versions
Opera89, Opera90, Opera91,
}
HTTP-Antwortstruktur, die von Client-Methoden zurückgegeben wird:
pub struct Response {
pub status: i32, // HTTP status code
pub used_protocol: String, // Protocol used ("h2" or "http/1.1")
pub body: String, // Response body content
pub headers: HashMap<String, Vec<String>>, // Response headers
pub cookies: HashMap<String, String>, // Set-Cookie values
}
Fehler: Failed to load library: cannot find tls-client-*.dll
Lösungen:
/usr/local/lib/ unter Linux/macOS)Selbst mit authentischen TLS-Fingerprints können zusätzliche Faktoren erforderlich sein:
Erforderliche Komponenten:
Vollständiges Beispiel:
let client = TlsClient::new(BrowserProfile::Firefox120)
.header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0")
.header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
.header("Accept-Language", "en-US,en;q=0.5")
.header("Accept-Encoding", "gzip, deflate, br")
.header("Connection", "keep-alive")
.header("Upgrade-Insecure-Requests", "1");
git clone https://github.com/yourusername/rust-tlsx
cd rust-tlsx
# Download required TLS library
wget https://github.com/bogdanfinn/tls-client/releases/download/v1.3.3/tls-client-windows-64-1.3.3.dll
# Build the project
cargo build --release
# Run tests
cargo test
cargo run --example simple_request
Beiträge sind willkommen! Weitere Hinweise findest du in CONTRIBUTING.md.
Bereiche für Verbesserungen:
Lizenziert unter einer der folgenden Lizenzen:
Die zugrunde liegende TLS-Client-Bibliothek verwendet die BSD-4-Clause-Lizenz.
| Library | TLS-Fingerprint | Leistung | Datenschutzstufe | Speicherverbrauch |
|---|
reqwest + rustls | Erkennbare Rust-Signatur | Basislinie | Niedrig | Hoch |
reqwest + native-tls | System-TLS (erkennbar) | Basislinie | Niedrig | Hoch |
hyper + hyper-tls | Generisches HTTP/2 | Schnell | Niedrig | Mittel |
ureq | Basis-TLS 1.2/1.3 | Langsam | Niedrig | Niedrig |
rust-tlsx | Perfekte Browser-Nachahmung | 6x schneller | Maximal | Optimiert |