d0rb/rusttlsx🦀 Cliente HTTP sigiloso para Rust. Imita las huellas TLS de navegadores reales para solicitudes indetectables. Rápido, con seguridad de tipos y diseñado para redes de precisión.
. Un cliente HTTP furtivo avanzado para Rust.
Diseñado para desarrolladores conscientes de la privacidad que necesitan control total sobre su huella de red.
Parece un navegador. Actúa como un navegador. Escrito en Rust.
Construido sobre bogdanfinn/tls-client - la biblioteca líder en huellas TLS (TLS fingerprinting) en la que confían profesionales de la seguridad de todo el mundo. Usamos las bibliotecas compartidas probadas en batalla de bogdanfinn (.dll/.so/.dylib) a través de enlaces FFI porque:
RustTLSX lleva esta tecnología probada a Rust con una API ergonómica y segura en cuanto a tipos que es 6 veces más rápida que las alternativas de Python.
Las aplicaciones web modernas analizan cada aspecto de tus solicitudes HTTP: no solo las cabeceras y las cookies, sino también las profundas firmas criptográficas de tu handshake TLS. Los clientes HTTP estándar de Rust (reqwest, hyper, ureq) generan patrones fácilmente detectables que identifican de inmediato el tráfico automatizado.
RustTLSX resuelve esto al ofrecer:
Descarga la biblioteca de cliente TLS necesaria para tu plataforma desde tls-client releases:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibColoca el archivo de la biblioteca en la raíz de tu proyecto, en la ruta de bibliotecas del sistema (/usr/local/lib/), o asegúrate de que sea accesible a través del PATH.
Añade RustTLSX a tu 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 admite más de 30 perfiles de navegador en los principales navegadores:
// 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 está construido sobre una base de excelencia probada en lugar de reinventar la rueda. Usamos las bibliotecas compiladas de bogdanfinn (.dll/.so/.dylib) a través de FFI porque:
Inversión en investigación: Bogdanfinn ha invertido miles de horas en ingeniería inversa del comportamiento TLS de los navegadores. Replicar esta investigación llevaría años y probablemente produciría resultados inferiores.
Fiabilidad probada en batalla: Estas bibliotecas son utilizadas por importantes empresas de seguridad, herramientas de privacidad e instituciones de investigación en todo el mundo. Han sido probadas contra todos los principales sistemas de protección.
Evolución continua: Las huellas de los navegadores cambian constantemente. Las bibliotecas de Bogdanfinn reciben actualizaciones periódicas para igualar las nuevas versiones de navegadores y las actualizaciones de los sistemas de protección.
Optimización del rendimiento: La implementación nativa en C/Go está altamente optimizada para la velocidad y la eficiencia de memoria, ofreciendo un rendimiento que las implementaciones puras de Rust no pueden igualar.
Carga dinámica en tiempo de ejecución: Las bibliotecas se cargan bajo demanda mediante FFI, eliminando la complejidad del enlazado estático y manteniendo el rendimiento.
Gestión de memoria: El modelo de ownership de Rust garantiza una interacción segura con las bibliotecas nativas, evitando fugas de memoria y errores de use-after-free comunes en las implementaciones de C/C++.
Manejo de errores: Un manejo de errores integral basado en Result proporciona diagnósticos detallados manteniendo la seguridad de tipos.
Gestión de conexiones: Agrupación y reutilización inteligente de conexiones TLS con patrones de comportamiento precisos como los de un navegador.
Las bibliotecas subyacentes gestionan cada aspecto del comportamiento TLS de los navegadores:
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 ofrece un rendimiento y una privacidad superiores en comparación con todos los clientes HTTP estándar de Rust:
Operaciones zero-copy: Las llamadas FFI directas a las bibliotecas C/Go optimizadas eliminan las copias de datos innecesarias que afectan a las implementaciones puras de Rust.
Agrupación de conexiones: Reutilización inteligente de conexiones TLS con un comportamiento keep-alive preciso como el de los navegadores, reduciendo la sobrecarga del handshake hasta en un 80%.
Eficiencia de memoria: El modelo de ownership de Rust combinado con bibliotecas nativas optimizadas da como resultado un uso de memoria un 40% menor que las soluciones equivalentes en Python.
Rendimiento concurrente: El soporte nativo de async con una multiplexación adecuada de conexiones se escala linealmente con los núcleos de la CPU.
frente a los bindings de Python para tls-client:
frente a tls-client en Go:
frente a las soluciones de Node.js:
Descarga el binario apropiado desde tls-client releases:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibColoca el archivo de la biblioteca en la raíz de tu proyecto, en el directorio de bibliotecas del sistema, o asegúrate de que sea accesible a través del 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 interfaz principal del cliente para realizar solicitudes HTTP con huellas TLS similares a las de un navegador.
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>
}
Enumeración de los perfiles de huella de navegador 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,
}
Estructura de respuesta HTTP devuelta por los métodos del cliente:
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
}
Error: Failed to load library: cannot find tls-client-*.dll
Soluciones:
/usr/local/lib/ en Linux/macOS)Incluso con huellas TLS auténticas, pueden ser necesarios factores adicionales:
Componentes Requeridos:
Ejemplo 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
# 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
¡Las contribuciones son bienvenidas! Consulta CONTRIBUTING.md para conocer las pautas.
Áreas de mejora:
Licenciado bajo cualquiera de las siguientes:
La biblioteca de cliente TLS subyacente utiliza la licencia BSD-4-Clause.
| Biblioteca | Huella TLS | Rendimiento | Nivel de Privacidad | Uso de Memoria |
|---|
reqwest + rustls | Firma Rust detectable | Línea base | Baja | Alto |
reqwest + native-tls | TLS del sistema (detectable) | Línea base | Baja | Alto |
hyper + hyper-tls | HTTP/2 genérico | Rápido | Baja | Medio |
ureq | TLS 1.2/1.3 básico | Lento | Baja | Bajo |
rust-tlsx | Imitación perfecta de navegador | 6 veces más rápido | Máximo | Optimizado |