d0rb/rusttlsx🦀 Client HTTP stealth per Rust. Imita le impronte TLS reali dei browser per richieste non rilevabili. Veloce, type-safe e progettato per un networking di precisione.
. Un client HTTP stealth avanzato per Rust.
Progettato per gli sviluppatori attenti alla privacy che necessitano di un controllo completo sulla propria impronta di rete.
Sembra un browser. Si comporta come un browser. Scritto in Rust.
Costruito su bogdanfinn/tls-client - la libreria leader del settore per l'impronta TLS, considerata affidabile dai professionisti della sicurezza in tutto il mondo. Utilizziamo le librerie condivise collaudate sul campo di bogdanfinn (.dll/.so/.dylib) tramite binding FFI perché:
RustTLSX porta questa tecnologia comprovata in Rust con un'API type-safe ed ergonomica che è 6 volte più veloce delle alternative Python.
Le applicazioni web moderne analizzano ogni aspetto delle tue richieste HTTP - non solo header e cookie, ma anche le profonde firme crittografiche dell'handshake TLS. I client HTTP standard di Rust (reqwest, hyper, ureq) generano pattern facilmente rilevabili che identificano immediatamente il traffico automatizzato.
RustTLSX risolve questo problema fornendo:
Scarica la libreria client TLS richiesta per la tua piattaforma dalle release di tls-client:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibPosiziona il file della libreria nella root del tuo progetto, nel percorso delle librerie di sistema (/usr/local/lib/), oppure assicurati che sia accessibile tramite PATH.
Aggiungi RustTLSX al tuo 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 supporta oltre 30 profili browser dei principali browser:
// Versioni Chrome
BrowserProfile::Chrome103
BrowserProfile::Chrome107
BrowserProfile::Chrome109
BrowserProfile::Chrome120
// Versioni Firefox
BrowserProfile::Firefox102
BrowserProfile::Firefox105
BrowserProfile::Firefox108
BrowserProfile::Firefox120
// Versioni Safari
BrowserProfile::Safari15_6_1
BrowserProfile::Safari16_0
BrowserProfile::SafariIos16_0
// Opera e altri
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); // secondi
let response = client.get("https://slow-api.example.com")?;
RustTLSX è costruito su fondamenta di eccellenza comprovata piuttosto che reinventare la ruota. Utilizziamo le librerie compilate di bogdanfinn (.dll/.so/.dylib) tramite FFI perché:
Investimento nella Ricerca: Bogdanfinn ha investito migliaia di ore nel reverse engineering del comportamento TLS dei browser. Replicare questa ricerca richiederebbe anni e produrrebbe probabilmente risultati inferiori.
Affidabilità Collaudata sul Campo: Queste librerie sono utilizzate da importanti aziende di sicurezza, strumenti per la privacy e istituti di ricerca in tutto il mondo. Sono state testate contro ogni principale sistema di protezione.
Evoluzione Continua: Le impronte dei browser cambiano costantemente. Le librerie di Bogdanfinn ricevono aggiornamenti regolari per corrispondere alle nuove versioni dei browser e agli aggiornamenti dei sistemi di protezione.
Ottimizzazione delle Prestazioni: L'implementazione nativa in C/Go è fortemente ottimizzata per velocità ed efficienza della memoria, offrendo prestazioni che le implementazioni pure in Rust non possono eguagliare.
Caricamento Dinamico a Runtime: Le librerie vengono caricate su richiesta tramite FFI, eliminando la complessità del linking statico pur mantenendo le prestazioni.
Gestione della Memoria: Il modello di ownership di Rust garantisce un'interazione sicura con le librerie native, prevenendo memory leak e bug use-after-free comuni nelle implementazioni C/C++.
Gestione degli Errori: Una gestione degli errori completa basata su Result fornisce diagnostiche dettagliate pur mantenendo la type safety.
Gestione delle Connessioni: Pooling e riutilizzo intelligente delle connessioni TLS con pattern di comportamento accurati rispetto ai browser.
Le librerie sottostanti gestiscono ogni aspetto del comportamento TLS del browser:
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!("Analisi dell'impronta TLS:\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!("Successo: {}", response.body),
401 => eprintln!("Autenticazione fallita"),
_ => eprintln!("Richiesta fallita con stato {}: {}", response.status, response.body),
}
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
fn main() -> anyhow::Result<()> {
// Crea un client che appare come un vero browser Firefox
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") // Orientato alla privacy: Do Not Track
.timeout(30);
// Includi i cookie di sessione per le richieste autenticate
let client = client.cookie("session_id", "your_session_token");
let response = client.get("https://example-site.com/data")?;
match response.status {
200 => println!("Dati recuperati con successo con una privacy simile a quella di un browser"),
403 => println!("Autenticazione richiesta - controlla i cookie di sessione"),
_ => println!("Risposta: {}", response.status),
}
Ok(())
}
use rust_tlsx::{TlsClient, BrowserProfile};
use std::collections::HashMap;
fn main() -> anyhow::Result<()> {
// Simula uno specifico ambiente browser
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);
// Effettua una richiesta indistinguibile da un browser reale
let response = client.get("https://api.example.com/sensitive-data")?;
println!("Dati recuperati con una perfetta mimica del browser");
println!("Protocollo utilizzato: {}", response.used_protocol);
Ok(())
}
RustTLSX offre prestazioni e privacy superiori rispetto a tutti i client HTTP standard di Rust:
Operazioni Zero-Copy: Chiamate FFI dirette a librerie C/Go ottimizzate eliminano la copia superflua dei dati che affligge le implementazioni pure in Rust.
Connection Pooling: Riutilizzo intelligente delle connessioni TLS con comportamento keep-alive accurato rispetto ai browser, riducendo l'overhead dell'handshake fino all'80%.
Efficienza della Memoria: Il modello di ownership di Rust combinato con librerie native ottimizzate comporta un utilizzo della memoria inferiore del 40% rispetto a soluzioni Python equivalenti.
Prestazioni Concorrenti: Supporto nativo async con un corretto multiplexing delle connessioni che scala linearmente con i core della CPU.
vs binding Python di tls-client:
vs tls-client in Go:
vs soluzioni Node.js:
Scarica il binario appropriato dalle release di tls-client:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibPosiziona il file della libreria nella root del tuo progetto, nella directory delle librerie di sistema, oppure assicurati che sia accessibile tramite 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(())
}
L'interfaccia client principale per effettuare richieste HTTP con impronte TLS simili a quelle dei browser.
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>
}
Enumerazione dei profili di impronta browser disponibili:
pub enum BrowserProfile {
// Versioni Chrome
Chrome103, Chrome104, Chrome105, Chrome106,
Chrome107, Chrome108, Chrome109, Chrome120,
// Versioni Firefox
Firefox102, Firefox104, Firefox105, Firefox106,
Firefox108, Firefox120,
// Versioni Safari
Safari15_6_1, Safari16_0,
SafariIpad15_6, SafariIos15_5, SafariIos15_6, SafariIos16_0,
// Versioni Opera
Opera89, Opera90, Opera91,
}
Struttura della risposta HTTP restituita dai metodi del client:
pub struct Response {
pub status: i32, // Codice di stato HTTP
pub used_protocol: String, // Protocollo utilizzato ("h2" o "http/1.1")
pub body: String, // Contenuto del corpo della risposta
pub headers: HashMap<String, Vec<String>>, // Header della risposta
pub cookies: HashMap<String, String>, // Valori Set-Cookie
}
Errore: Failed to load library: cannot find tls-client-*.dll
Soluzioni:
/usr/local/lib/ su Linux/macOS)Anche con impronte TLS autentiche, potrebbero essere richiesti fattori aggiuntivi:
Componenti Richiesti:
Esempio Completo:
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
# Scarica la libreria TLS richiesta
wget https://github.com/bogdanfinn/tls-client/releases/download/v1.3.3/tls-client-windows-64-1.3.3.dll
# Compila il progetto
cargo build --release
# Esegui i test
cargo test
cargo run --example simple_request
I contributi sono benvenuti! Consulta CONTRIBUTING.md per le linee guida.
Aree di miglioramento:
Concesso in licenza con una delle seguenti:
La libreria client TLS sottostante utilizza la licenza BSD-4-Clause.
| Libreria | Impronta TLS | Prestazioni | Livello di Privacy | Utilizzo di Memoria |
|---|
reqwest + rustls | Firma Rust rilevabile | Baseline | Bassa | Alto |
reqwest + native-tls | TLS di sistema (rilevabile) | Baseline | Bassa | Alto |
hyper + hyper-tls | HTTP/2 generico | Veloce | Bassa | Medio |
ureq | TLS 1.2/1.3 di base | Lento | Bassa | Basso |
rust-tlsx | Perfetta mimica del browser | 6 volte più veloce | Massima | Ottimizzato |