d0rb/rusttlsx🦀 Client HTTP furtif pour Rust . imite les empreintes TLS de navigateurs réels pour des requêtes indétectables. Rapide, type-safe et conçu pour une mise en réseau de précision.
. Un client HTTP furtif avancé pour Rust.
Conçu pour les développeurs soucieux de leur confidentialité qui ont besoin d'un contrôle total sur leur empreinte réseau.
Ressemble à un navigateur. Se comporte comme un navigateur. Écrit en Rust.
Construit sur bogdanfinn/tls-client — la bibliothèque de référence en matière d'empreintes TLS, plébiscitée par les professionnels de la sécurité du monde entier. Nous utilisons les bibliothèques partagées éprouvées de bogdanfinn (.dll/.so/.dylib) via des liaisons FFI parce que :
RustTLSX apporte cette technologie éprouvée à Rust avec une API type-safe et ergonomique, 6 fois plus rapide que les alternatives Python.
Les applications web modernes analysent chaque aspect de vos requêtes HTTP — non seulement les en-têtes et les cookies, mais aussi les signatures cryptographiques profondes de votre négociation TLS. Les clients HTTP standard de Rust (reqwest, hyper, ureq) génèrent des modèles facilement détectables qui identifient immédiatement le trafic automatisé.
RustTLSX résout ce problème en offrant :
Téléchargez la bibliothèque cliente TLS requise pour votre plateforme depuis les versions de tls-client :
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibPlacez le fichier de bibliothèque dans la racine de votre projet, dans le chemin des bibliothèques système (/usr/local/lib/), ou assurez-vous qu'il est accessible via le PATH.
Ajoutez RustTLSX à votre Cargo.toml :
[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 prend en charge plus de 30 profils de navigateurs couvrant les principaux navigateurs :
// 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 repose sur une fondation d'excellence prouvée plutôt que de réinventer la roue. Nous utilisons les bibliothèques compilées de bogdanfinn (.dll/.so/.dylib) via FFI parce que :
Investissement en recherche : Bogdanfinn a investi des milliers d'heures dans la rétro-ingénierie du comportement TLS des navigateurs. Répliquer cette recherche prendrait des années et produirait probablement des résultats inférieurs.
Fiabilité éprouvée : Ces bibliothèques sont utilisées par les grandes sociétés de sécurité, les outils de protection de la vie privée et les instituts de recherche du monde entier. Elles ont été testées contre tous les principaux systèmes de protection.
Évolution continue : Les empreintes des navigateurs changent constamment. Les bibliothèques de bogdanfinn reçoivent des mises à jour régulières pour correspondre aux nouvelles versions de navigateurs et aux mises à jour des systèmes de protection.
Optimisation des performances : L'implémentation native en C/Go est fortement optimisée pour la vitesse et l'efficacité mémoire, offrant des performances que les implémentations purement Rust ne peuvent pas égaler.
Chargement dynamique à l'exécution : Les bibliothèques sont chargées à la demande via FFI, éliminant la complexité de la liaison statique tout en conservant les performances.
Gestion de la mémoire : Le modèle de propriété de Rust garantit une interaction sûre avec les bibliothèques natives, empêchant les fuites de mémoire et les bugs d'utilisation après libération courants dans les implémentations C/C++.
Gestion des erreurs : Une gestion complète des erreurs basée sur Result fournit des diagnostics détaillés tout en maintenant la sécurité de type.
Gestion des connexions : Mise en commun intelligente et réutilisation des connexions TLS avec des modèles de comportement conformes aux navigateurs.
Les bibliothèques sous-jacentes gèrent tous les aspects du comportement TLS des navigateurs :
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 offre des performances et une confidentialité supérieures à tous les clients HTTP Rust standard :
Opérations zéro-copie : Les appels FFI directs aux bibliothèques C/Go optimisées éliminent les copies de données inutiles qui affectent les implémentations purement Rust.
Mise en commun des connexions : Réutilisation intelligente des connexions TLS avec un comportement keep-alive conforme aux navigateurs, réduisant le surcoût de la négociation TLS jusqu'à 80 %.
Efficacité mémoire : Le modèle de propriété de Rust combiné aux bibliothèques natives optimisées permet une utilisation mémoire inférieure de 40 % à celle des solutions Python équivalentes.
Performances simultanées : La prise en charge native de l'asynchrone avec un multiplexage approprié des connexions évolue linéairement avec le nombre de cœurs CPU.
vs les liaisons Python de tls-client :
vs tls-client en Go :
vs les solutions Node.js :
Téléchargez le binaire approprié depuis les versions de tls-client :
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibPlacez le fichier de bibliothèque dans la racine de votre projet, dans le répertoire des bibliothèques système, ou assurez-vous qu'il est accessible via le PATH.
[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(())
}
La principale interface client pour effectuer des requêtes HTTP avec des empreintes TLS semblables à celles des navigateurs.
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>
}
Énumération des profils d'empreintes de navigateur disponibles :
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,
}
Structure de réponse HTTP renvoyée par les méthodes du client :
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
}
Erreur : Failed to load library: cannot find tls-client-*.dll
Solutions :
/usr/local/lib/ sur Linux/macOS)Même avec des empreintes TLS authentiques, des facteurs supplémentaires peuvent être nécessaires :
Composants requis :
Exemple complet :
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
Les contributions sont les bienvenues ! Veuillez consulter CONTRIBUTING.md pour les directives.
Domaines d'amélioration :
Distribué sous l'une ou l'autre des licences suivantes :
La bibliothèque cliente TLS sous-jacente utilise la licence BSD-4-Clause.
| Bibliothèque | Empreinte TLS | Performances | Niveau de confidentialité | Utilisation mémoire |
|---|
reqwest + rustls | Signature Rust détectable | Référence | Faible | Élevée |
reqwest + native-tls | TLS système (détectable) | Référence | Faible | Élevée |
hyper + hyper-tls | HTTP/2 générique | Rapide | Faible | Moyenne |
ureq | TLS 1.2/1.3 basique | Lent | Faible | Faible |
rust-tlsx | Imitation parfaite du navigateur | 6x plus rapide | Maximum | Optimisée |