d0rb/rusttlsx🦀 Cliente HTTP furtivo para Rust. Imita impressões digitais TLS reais de navegadores para solicitações indetectáveis. Rápido, type-safe e construído para networking de precisão.
. Um cliente HTTP furtivo avançado para Rust.
Construído para desenvolvedores preocupados com privacidade que precisam de controle total sobre sua impressão digital de rede.
Parece um navegador. Age como um navegador. Escrito em Rust.
Construído sobre bogdanfinn/tls-client - a biblioteca líder do setor para impressão digital TLS, confiável por profissionais de segurança em todo o mundo. Usamos as bibliotecas compartilhadas comprovadas em batalha do bogdanfinn (.dll/.so/.dylib) por meio de bindings FFI porque:
RustTLSX traz essa tecnologia comprovada para Rust com uma API ergonômica e type-safe, 6x mais rápida que as alternativas em Python.
Aplicações web modernas analisam todos os aspectos das suas requisições HTTP - não apenas cabeçalhos e cookies, mas as assinaturas criptográficas profundas do seu handshake TLS. Clientes HTTP padrão do Rust (reqwest, hyper, ureq) geram padrões facilmente detectáveis que identificam imediatamente tráfego automatizado.
O RustTLSX resolve isso fornecendo:
Baixe a biblioteca TLS client necessária para sua plataforma nos lançamentos do tls-client:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibColoque o arquivo da biblioteca na raiz do seu projeto, no caminho de bibliotecas do sistema (/usr/local/lib/) ou garanta que ele esteja acessível via PATH.
Adicione o RustTLSX ao seu 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(())
}
O RustTLSX suporta mais de 30 perfis de navegador nos principais 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")?;
O RustTLSX é construído sobre uma base de excelência comprovada em vez de reinventar a roda. Usamos as bibliotecas compiladas do bogdanfinn (.dll/.so/.dylib) por meio de FFI porque:
Investimento em Pesquisa: O Bogdanfinn investiu milhares de horas em engenharia reversa do comportamento TLS dos navegadores. Replicar essa pesquisa levaria anos e provavelmente produziria resultados inferiores.
Confiabilidade Comprovada em Batalha: Essas bibliotecas são usadas por grandes empresas de segurança, ferramentas de privacidade e instituições de pesquisa em todo o mundo. Elas foram testadas contra todos os principais sistemas de proteção.
Evolução Contínua: As impressões digitais dos navegadores mudam constantemente. As bibliotecas do Bogdanfinn recebem atualizações regulares para acompanhar novas versões de navegadores e atualizações dos sistemas de proteção.
Otimização de Performance: A implementação nativa em C/Go é fortemente otimizada para velocidade e eficiência de memória, oferecendo performance que implementações Rust puras não conseguem igualar.
Carregamento Dinâmico em Tempo de Execução: As bibliotecas são carregadas sob demanda usando FFI, eliminando a complexidade da ligação estática enquanto mantém a performance.
Gerenciamento de Memória: O modelo de ownership do Rust garante interação segura com bibliotecas nativas, prevenindo vazamentos de memória e bugs de use-after-free comuns em implementações C/C++.
Tratamento de Erros: Tratamento abrangente de erros baseado em Result fornece diagnósticos detalhados enquanto mantém a type safety.
Gerenciamento de Conexões: Pooling inteligente e reutilização de conexões TLS com padrões de comportamento precisos como no navegador.
As bibliotecas subjacentes gerenciam todos os aspectos do comportamento TLS do navegador:
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(())
}
O RustTLSX oferece performance e privacidade superiores em comparação a todos os clientes HTTP Rust padrão:
Operações Zero-Copy: Chamadas FFI diretas a bibliotecas C/Go otimizadas eliminam a cópia desnecessária de dados que prejudica implementações Rust puras.
Pooling de Conexões: Reutilização inteligente de conexões TLS com comportamento keep-alive preciso como no navegador, reduzindo o overhead do handshake em até 80%.
Eficiência de Memória: O modelo de ownership do Rust combinado com bibliotecas nativas otimizadas resulta em 40% menos uso de memória que soluções Python equivalentes.
Performance Concorrente: Suporte nativo a async com multiplexação adequada de conexões escala linearmente com os núcleos da CPU.
vs bindings Python do tls-client:
vs tls-client em Go:
vs soluções Node.js:
Baixe o binário apropriado dos lançamentos do tls-client:
tls-client-windows-64-1.3.3.dlltls-client-linux-ubuntu-amd64-1.3.3.sotls-client-darwin-amd64-1.3.3.dylibColoque o arquivo da biblioteca na raiz do seu projeto, no diretório de bibliotecas do sistema ou garanta que ele esteja acessível via 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(())
}
A interface principal do cliente para fazer requisições HTTP com impressões digitais TLS semelhantes às de um 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>
}
Enumeração dos perfis de impressão digital de navegador disponíveis:
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,
}
Estrutura de resposta HTTP retornada pelos métodos do 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
}
Erro: Failed to load library: cannot find tls-client-*.dll
Soluções:
/usr/local/lib/ no Linux/macOS)Mesmo com impressões digitais TLS autênticas, fatores adicionais podem ser necessários:
Componentes Necessários:
Exemplo 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
Contribuições são bem-vindas! Consulte CONTRIBUTING.md para obter as diretrizes.
Áreas para melhoria:
Licenciado sob uma das seguintes licenças:
A biblioteca TLS client subjacente usa a licença BSD-4-Clause.
| Biblioteca | Impressão Digital TLS | Performance | Nível de Privacidade | Uso de Memória |
|---|
reqwest + rustls | Assinatura Rust detectável | Baseline | Baixo | Alto |
reqwest + native-tls | TLS do sistema (detectável) | Baseline | Baixo | Alto |
hyper + hyper-tls | HTTP/2 genérico | Rápido | Baixo | Médio |
ureq | TLS 1.2/1.3 básico | Lento | Baixo | Baixo |
rust-tlsx | Mimetização perfeita do navegador | 6x mais rápido | Máximo | Otimizado |