RustTLSX 🦀

. 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.

Crediti e Fondamenta

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é:

• Anni di Ricerca: Migliaia di ore per perfezionare la replica del comportamento TLS dei browser
• Track Record Comprovato: Utilizzata in produzione da aziende di sicurezza e strumenti per la privacy a livello globale
• Aggiornamenti Continui: Aggiornamenti regolari per corrispondere alle impronte dei browser in evoluzione
• Prestazioni Ottimizzate: Implementazione nativa in C/Go per la massima velocità

RustTLSX porta questa tecnologia comprovata in Rust con un'API type-safe ed ergonomica che è 6 volte più veloce delle alternative Python.

Perché Esiste RustTLSX

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:

• Perfetta Mimica del Browser: Impronte TLS autentiche provenienti da browser reali
• Controllo sulla Modifica delle Richieste: Controllo granulare su header, cookie e temporizzazione
• Privacy by Design: Il tuo traffico appare come sessioni browser legittime
• Leadership nelle Prestazioni: Significativamente più veloce di qualsiasi soluzione alternativa

Funzionalità Principali

Privacy e Controllo delle Richieste

• Identità Browser Autentica: Perfetta replica delle firme TLS di Chrome, Firefox, Safari e Opera
• Manipolazione degli Header: Controllo completo su header, user agent e parametri accept
• Gestione dei Cookie: Gestione avanzata delle sessioni con supporto ai cookie persistenti
• Controllo della Temporizzazione: Intervalli di richiesta configurabili e connection pooling
• Selezione del Protocollo: Supporto HTTP/1.1 e HTTP/2 con preferenze accurate rispetto ai browser

Vantaggi in Termini di Prestazioni

• 6 volte più veloce di Python: Prestazioni native Rust con operazioni zero-copy dove possibile
• Efficiente in Termini di Memoria: Sovraccarico minimo rispetto ai client HTTP standard
• Richieste Concorrenti: Ottimizzato per scenari ad alta produttività
• Riutilizzo delle Connessioni: Connection pooling intelligente che rispecchia il comportamento dei browser

Funzionalità Avanzate

• Oltre 30 Profili Browser: Vasta collezione di impronte browser reali
• Type Safety: Garanzie complete a tempo di compilazione di Rust con gestione degli errori esaustiva
• Cross-Platform: Supporto per Windows, Linux e macOS
• Bypass delle Protezioni: Come effetto collaterale della perfetta mimica, aggira i sistemi di rilevamento

Avvio Rapido

Prerequisiti

Scarica la libreria client TLS richiesta per la tua piattaforma dalle release di tls-client:

• Windows: tls-client-windows-64-1.3.3.dll
• Linux: tls-client-linux-ubuntu-amd64-1.3.3.so
• macOS: tls-client-darwin-amd64-1.3.3.dylib

Posiziona 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.

Installazione

Aggiungi RustTLSX al tuo Cargo.toml:

[dependencies]
rust-tlsx = "0.1"

Utilizzo Base

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(())
}

Profili Browser Disponibili

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

Utilizzo Avanzato

Header e Cookie Personalizzati

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")?;

Richieste POST

let body = r#"{"username": "user", "password": "pass"}"#;
let response = client.post("https://example.com/login", Some(body.to_string()))?;

Timeout delle Richieste

let client = TlsClient::new(BrowserProfile::Firefox120)
    .timeout(60); // secondi

let response = client.get("https://slow-api.example.com")?;

Architettura e Filosofia di Progettazione

Perché Utilizziamo le Librerie Condivise di bogdanfinn

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.

Implementazione Tecnica

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.

Componenti dell'Impronta Gestiti