Spiegato: JA3, JA4, e come evitare la rilevazione

Che cosa è TLS Fingerprinting?

L'impronta digitale TLS è una tecnica di rilevamento passivo che identifica i client in base a come avviano connessioni crittografate. Ogni volta che la libreria HTTP si connette a un sito web tramite HTTPS, invia un messaggio TLS ClientHello contenente suite di cifrari, estensioni, curve ellittiche e altri parametri in un ordine specifico. I sistemi anti-bot analizzano questa stretta di mano per determinare se il client di collegamento corrisponde a ciò che il suo utente-agente sostiene di essere.

Diversamente browser impronta digitale, che richiede l'esecuzione di JavaScript, TLS impronte funziona sul livello di rete — prima che qualsiasi contenuto di pagina venga consegnato. Questo lo rende uno dei primi e più difficili segnali di rilevamento per evadere, come coperto nel nostro guida completa su come i sistemi anti-bot rilevano i proxy.

Come funziona TLS Handshakes

Prima che i dati HTTP vengano scambiati su HTTPS, il client e il server eseguono una stretta di mano TLS. Il primo messaggio critico — il ClientHello — contiene tutto il necessario per l'impronta digitale dei sistemi anti-bot:

1. Versione TLS: La versione TLS massima supporta il client (ad esempio TLS 1.2, TLS 1.3).
2. Suite di cifratura: Un elenco ordinato di algoritmi di crittografia il cliente è disposto a utilizzare.
3. Estensioni: Ulteriori funzionalità come Indicazione nome server (SNI), ALPN, algoritmi di firma e gruppi di condivisione chiave.
4. Curve ellittiche: Tipi di curva supportati per lo scambio di chiavi (ad esempio, x25519, secp256r1).
5. Metodi di compressione: Tipicamente nullo nelle implementazioni moderne, ma la loro presenza o assenza è ancora un segnale.

Ogni libreria HTTP, browser e linguaggio di programmazione runtime produce un modello CustomerHello distinto. Chrome, Firefox, Safari, Python's requests♪ net/http, e Node.js ciascuno hanno firme riconoscibili.

JA3 Impronte per la stampa

JA3 è il metodo di impronta digitale TLS più diffuso. Sviluppato da ingegneri Salesforce, crea un hash MD5 da cinque campi nel messaggio ClientHello:

Questi cinque valori sono concatenati con virgole e hashed per produrre un'impronta digitale JA3 a 32 caratteri. Ad esempio, Python's requests libreria produce un hash diverso JA3 rispetto a Chrome, anche quando entrambi impostano la stessa stringa user-agent.

JA3 Rilevamento della pratica

# Example JA3 hash computation (conceptual)
# ClientHello fields → concatenated string → MD5 hash
# Python requests (urllib3/OpenSSL) — distinct JA3
# ja3: 771,4866-4867-4865-49196-49200-159-52393-52392-52394...,0-23-65281-10-11...
# ja3_hash: "773906b0efdefa24a7f2b8eb6985bf37"
# Chrome 120+ — different cipher order, different extensions
# ja3: 771,4865-4866-4867-49195-49199-49196-49200-52393-52392...,0-23-65281-10-11...
# ja3_hash: "cd08e31494f9531f560d64c695473da9"
# The hash reveals the client library, regardless of User-Agent

JA4 — La prossima generazione

JA4, anche da Salesforce, migliora su JA3 producendo un'impronta digitale più leggibile e robusta. Invece di un hash MD5 opaco, JA4 crea un identificatore strutturato con tre componenti:

• JA4 a: Tipo di protocollo + versione TLS + presenza SNI + conteggio cifrario + numero di estensione + ALPN primo valore (ad esempio, "t13d1517h2 8daaf6152771 b0da82dd1658").
• JA4 b: Hash troncato in ordine di suite di cifrari.
• JA4 c: Frequenza troncata ordinata di estensioni (con SNI e ALPN rimossa per ridurre la variabilità).

JA4 è più difficile da spoof perché incorpora segnali aggiuntivi e utilizza un formato che resiste alla semplice corrispondenza hash.

Impronte TLS comuni dal cliente

Perché TLS Fingerprinting è difficile da Evade

L'impronta digitale TLS presenta sfide uniche rispetto ad altri metodi di rilevamento:

• Rilevamento a livello di rete: Funziona prima che qualsiasi contenuto HTTP venga scambiato, quindi non può essere sconfitto da JavaScript iniezione o manipolazione dell'intestazione.
• Firma a livello bibliotecario: L'impronta digitale è determinata dalla libreria TLS compilata nel vostro runtime, non dal vostro codice di applicazione. Cambiare la stringa user-agent ha effetto zero sull'impronta digitale TLS.
• Trasparenza del proxy: Processi standard HTTP/HTTPS (compreso Prossi residenziali) inoltrare la stretta di mano TLS dal client al server, quindi l'origine vede la vera impronta TLS del tuo cliente.
• Attacco versione: Ogni versione minore di una libreria TLS può produrre un'impronta digitale leggermente diversa, rendendo la versione rilevabile.

Strategie di mitigazione di stampaggio della TLS

1. Utilizzare le libbre TLS del browser

L'approccio più efficace è quello di utilizzare librerie TLS che producono i messaggi del client identici al browser:

# Python: Use curl_cffi to mimic browser TLS fingerprints
# pip install curl_cffi
from curl_cffi import requests
# Impersonate Chrome's TLS fingerprint
response = requests.get(
    "https://example.com",
    impersonate="chrome",
    proxies={
        "http": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080",
        "https": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
    }
)
print(response.status_code)

2. Utilizzare utls in Go

// Go: Use uTLS to mimic browser TLS fingerprints
// go get github.com/refraction-networking/utls
package main
import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "crypto/tls"
    tls2 "github.com/refraction-networking/utls"
)
func main() {
    proxyURL, _ := url.Parse("http://USERNAME:PASSWORD@gate.proxyhat.com:8080")
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        TLSClientConfig: &tls.Config{InsecureSkipVerify: false},
    }
    // uTLS allows you to specify a ClientHelloID that mimics
    // specific browsers (Chrome, Firefox, Safari, etc.)
    // This requires custom dial integration — see uTLS docs
    _ = tls2.HelloChrome_Auto // Example: mimic Chrome
    client := &http.Client{Transport: transport}
    resp, err := client.Get("https://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body[:100]))
}

3. Utilizzare Node.js con TLS personalizzato

// Node.js: Use got-scraping for browser-like TLS
// npm install got-scraping
import { gotScraping } from 'got-scraping';
const response = await gotScraping({
    url: 'https://example.com',
    proxyUrl: 'http://USERNAME:PASSWORD@gate.proxyhat.com:8080',
    headerGeneratorOptions: {
        browsers: ['chrome'],
        operatingSystems: ['windows'],
    }
});
// got-scraping uses custom TLS settings to mimic browser fingerprints
console.log(response.statusCode);

4. Utilizzare browser senza testa

I browser senza testa (Puppeteer, Playwright) producono le impronte del browser TLS autentico perché utilizzano il vero stack del browser TLS. Questa è la mitigazione più affidabile, ma anche la più estesa risorsa. Vedi la nostra guida raschiamento senza bloccarsi per i dettagli di configurazione.

Testare il tuo TLS Fingerprint

Prima di distribuire il raschietto, verificare la sua impronta TLS contro i servizi di rilevamento:

# Check your JA3 fingerprint against a test service
# Using Python with curl_cffi
from curl_cffi import requests
response = requests.get(
    "https://tls.peet.ws/api/all",
    impersonate="chrome",
    proxies={
        "http": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080",
        "https": "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
    }
)
data = response.json()
print(f"JA3 Hash: {data.get('tls', {}).get('ja3_hash', 'N/A')}")
print(f"JA4: {data.get('tls', {}).get('ja4', 'N/A')}")
print(f"HTTP Version: {data.get('http_version', 'N/A')}")

La tua impronta TLS è determinata dalla tua libreria client HTTP, non dal tuo proxy. Passare dal datacenter ai proxy residenziali cambia la tua reputazione IP ma non cambia la tua firma TLS. Entrambi gli strati devono essere affrontati.

HTTP/2 Fingerprinting

Oltre a TLS, il protocollo HTTP/2 stesso rivela l'identità del cliente attraverso le impostazioni di connessione, l'ordine del telaio dell'intestazione e i frame prioritari. I sistemi anti-bot combinano le impronte TLS e HTTP/2 per una maggiore precisione:

Biblioteche come curl_cffi e got-scraping indirizzo HTTP/2 impronta digitale oltre a TLS impronta digitale.

Combinando la mitigazione TLS con la rotazione del proxy

Un efficace anti-detezione strati strategia TLS impronta digitale corrispondente con rotazione proxy di alta qualità:

1. Abbina TLS a user-agent: Se il tuo utente-agente sostiene Chrome, l'impronta digitale TLS deve corrispondere a Chrome.
2. Utilizzare i proxy residenziali: I proxy residenziali di ProxyHat fornire IP puliti che completano le firme TLS di livello del browser.
3. Ruotare costantemente: Ogni sessione dovrebbe utilizzare un profilo IP + TLS corrispondente + combinazione di user-agent.
4. Evitare di mescolare librerie: Non riutilizzare lo stesso IP con diverse impronte digitali TLS — questo è un segnale bot forte.
5. Test prima della distribuzione: Verificare che le tue impronte corrispondano al tuo browser rivendicato utilizzando endpoint di test.

Per l'integrazione dei proxy specifici per la lingua, vedere le nostre guide per Python♪ Node.jse Vai..

Considerazioni etiche e giuridiche

La mimica delle impronte digitali TLS dovrebbe essere utilizzata responsabilmente. I casi di utilizzo legittimi includono:

• Accedere ai dati pubblicamente disponibili tramite connessioni HTTPS standard
• Ricerca di sicurezza e test di penetrazione della propria infrastruttura
• Assicurare i test automatizzati simulare con precisione il comportamento reale del browser
• Ricerca sulla privacy che studia come l'impronta digitale TLS influisce sul monitoraggio degli utenti

Sempre rispettare i termini del sito web di servizio, limiti di tariffa e regolamenti applicabili. Fare riferimento a Documentazione di ProxyHat per linee guida di utilizzo responsabili.

Domande frequenti