Generatore di chiavi Web Bot Auth per firme HTTP sicure

Nel panorama digitale attuale, i bot sono ovunque: crawler per motori di ricerca, agenti AI che analizzano contenuti, strumenti di monitoraggio. Finora, l’identificazione di questi agenti si è basata su segnali deboli come lo User-Agent o l’indirizzo IP. Peccato che entrambi siano facilmente falsificabili: uno script Python può dichiarare di essere Googlebot con una semplice riga di codice, e un proxy può mascherare l’origine delle richieste. Il risultato? Siti che bloccano indiscriminatamente o, peggio, concedono accesso a bot malevoli spacciatisi per legittimi.

Il Generatore chiavi Web Bot Auth risponde a questa esigenza introducendo un meccanismo di autenticazione crittografica basato sugli standard IETF in fase di definizione, in particolare le HTTP Message Signatures (RFC 9421). L’idea è semplice: invece di affidarsi a stringhe o IP, ogni richiesta HTTP viene firmata digitalmente con una chiave privata. Il sito che riceve la richiesta verifica la firma confrontandola con una chiave pubblica pubblicata in un percorso standard (/.well-known/http-message-signatures-directory). Se la firma è valida, il bot è autenticato; altrimenti, la richiesta viene rifiutata.

Questo approccio offre vantaggi concreti: - Non ripudiabilità: una firma digitale non può essere generata senza la chiave privata, quindi un bot non può negare di aver effettuato una richiesta. - Tracciabilità: ogni chiave è associata a un identificativo univoco (keyid), che consente ai siti di distinguere tra bot diversi anche se usano lo stesso User-Agent. - Flessibilità: le chiavi possono avere una scadenza (exp) o una data di inizio validità (nbf), permettendo una rotazione sicura senza interruzioni.

Naturalmente, il sistema non è ancora uno standard definitivo: le specifiche sono ancora in fase di Internet-Draft, il che significa che potrebbero subire modifiche. Tuttavia, l’adozione anticipata consente ai gestori di bot di prepararsi per il futuro, soprattutto in un contesto in cui l’IA generativa sta moltiplicando il numero di agenti automatizzati che interagiscono con il web. Il Generatore chiavi Web Bot Auth semplifica questo passaggio, fornendo tutto il necessario per iniziare senza dover implementare manualmente le specifiche tecniche.

Quando si utilizza il Generatore chiavi Web Bot Auth, il risultato non è solo una coppia di chiavi crittografiche, ma un vero e proprio starter kit pronto all’uso. Ogni output è pensato per guidare l’utente passo dopo passo, dalla generazione delle chiavi alla firma delle richieste. Ecco cosa viene prodotto, e a cosa serve ciascun elemento:

1. *Identificativo della chiave (keyid): un valore univoco calcolato come impronta SHA-256 della chiave pubblica in formato JWK (RFC 7638). Questo keyid* viene incluso in ogni firma e consente al server di individuare rapidamente la chiave pubblica corretta nel directory.

1. Directory delle chiavi pubbliche (JSON): un file in formato JSON contenente la chiave pubblica (senza il parametro privato d), da pubblicare nel percorso /.well-known/http-message-signatures-directory. Il file può includere campi opzionali come nbf (not before) e exp (expiration), utili per gestire la rotazione delle chiavi. Ad esempio, una chiave con "exp": [date=2024-12-31] scadrà automaticamente a fine anno.

1. Intestazioni di risposta per il directory: un esempio di intestazioni HTTP da restituire quando un client richiede il directory, complete di una firma valida per 24 ore. Questa firma dimostra che il directory stesso è autentico e non è stato manomesso.

4. Chiave privata (JWK e PKCS#8 PEM): la chiave privata viene generata localmente nel browser tramite Web Crypto e mai trasmessa. È disponibile in due formati: - JWK: un oggetto JSON contenente tutti i parametri della chiave, compreso il campo d (il segreto). Questo formato è utile per l’integrazione con librerie JavaScript. - PKCS#8 PEM: una versione testuale della chiave privata, compatibile con strumenti come OpenSSL o librerie in altri linguaggi (Python, Go, ecc.).

1. Chiave pubblica (SPKI PEM): la chiave pubblica in formato testuale, utile per la verifica manuale o l’integrazione con sistemi che non supportano JWK.

1. Esempio di richiesta firmata: un esempio completo di richiesta HTTP firmata, con intestazioni Signature e Signature-Input, più un comando curl pronto all’uso. La firma copre componenti come @authority e signature-agent, e include un tag web-bot-auth per identificare lo scopo della firma. La richiesta scade dopo 5 minuti, simulando un caso d’uso reale.

1. Signature base: il testo esatto che viene firmato, mostrato riga per riga. Questo è fondamentale per il debugging: se una firma viene rifiutata, confrontando la signature base generata dal proprio codice con quella di riferimento si possono individuare errori di formattazione o componenti mancanti.

Tutti questi elementi sono generati localmente e non vengono salvati: ricaricando la pagina, le chiavi scompaiono. Questo approccio garantisce la massima privacy, ma richiede di scaricare e conservare la chiave privata in un luogo sicuro, come un gestore di segreti (ad esempio, AWS Secrets Manager o HashiCorp Vault).

Una volta generata la chiave pubblica con il Generatore chiavi Web Bot Auth, il passo successivo è pubblicarla in modo che i siti possano verificarne le firme. Il percorso standard per il directory è /.well-known/http-message-signatures-directory, un endpoint definito dalle specifiche IETF per la scoperta delle chiavi pubbliche. Questo percorso deve essere accessibile tramite HTTPS e restituire un file JSON con Content-Type: application/json.

Il file JSON deve contenere almeno la chiave pubblica in formato JWK, ma può includere anche metadati aggiuntivi: - nbf (not before): la data e ora da cui la chiave è valida. Utile per pianificare l’attivazione di una nuova chiave senza interrompere il servizio. - exp (expiration): la data e ora di scadenza della chiave. Dopo questa data, le firme generate con la chiave privata corrispondente verranno rifiutate. Ad esempio, una chiave con "exp": [date=2024-06-30] scadrà il 30 giugno 2024.

Un esempio di directory valido potrebbe essere:

{
  "keys": [
    {
      "kty": "OKP",
      "crv": "Ed25519",
      "kid": "z6MkqRYqQiSgvZQdnBytw86Qbs2ZWUkGv22od935YF4s8M7V",
      "x": "oB13Vqn5Z0JXZ1zZ1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Y",
      "nbf": [date=2024-01-01],
      "exp": [date=2024-12-31]
    }
  ]
}

Il directory stesso deve essere firmato: le specifiche richiedono che la risposta HTTP includa intestazioni Signature e Signature-Input per dimostrare che il contenuto non è stato alterato. Il Generatore chiavi Web Bot Auth fornisce un esempio di queste intestazioni, ma in produzione è necessario firmare nuovamente il directory ogni volta che viene richiesto, poiché le firme hanno una durata limitata (tipicamente 24 ore).

La rotazione delle chiavi è un aspetto cruciale per la sicurezza. Se una chiave privata viene compromessa, è possibile revocarla pubblicando una nuova chiave e impostando una data di scadenza per quella vecchia. Il campo exp consente di automatizzare questo processo: i siti verificheranno automaticamente che la chiave sia ancora valida prima di accettare una firma. Tuttavia, è importante non impostare scadenze troppo brevi (ad esempio, 30 giorni), perché richiederebbero una rotazione frequente, aumentando il rischio di errori operativi.

Un errore comune è pubblicare il directory senza il Content-Type corretto. Se il server restituisce text/plain o un tipo MIME errato, i client potrebbero rifiutare il file. Inoltre, il percorso deve essere esattamente /.well-known/http-message-signatures-directory: qualsiasi variazione (ad esempio, /well-known/http-message-signatures) non sarà riconosciuta dalle implementazioni conformi alle specifiche.

Firmare una richiesta HTTP con il Generatore chiavi Web Bot Auth significa aggiungere due intestazioni: Signature-Input e Signature. La prima descrive cosa viene firmato e come, mentre la seconda contiene la firma vera e propria. Vediamo nel dettaglio come si costruisce una firma conforme alle specifiche RFC 9421.

Componenti coperti dalla firma La firma non riguarda solo il corpo della richiesta, ma anche parti specifiche dell’intestazione HTTP. I componenti più comuni sono: - @method: il metodo HTTP (GET, POST, ecc.). - @authority: l’host e la porta del server (ad esempio, www.esempio.it:443). - @target-uri: l’URI completo della richiesta (ad esempio, /pagina.html). - signature-agent: l’origine HTTPS che ospita il directory delle chiavi (ad esempio, https://bot.mio-sito.it). - content-digest: un hash del corpo della richiesta, se presente.

Ogni componente viene identificato da un nome preceduto da @ (per i componenti standard) o da un nome personalizzato. Nell’esempio fornito dal generatore, la firma include @authority e signature-agent, oltre a un tag web-bot-auth per identificare lo scopo della firma.

Parametri di Signature-Input L’intestazione Signature-Input specifica i parametri della firma, tra cui: - keyid: l’identificativo della chiave (keyid), calcolato come impronta JWK. - alg: l’algoritmo di firma, in questo caso ed25519. - created: il timestamp di creazione della firma (in secondi dal 1970). - expires: il timestamp di scadenza della firma. Nell’esempio del generatore, la firma scade dopo 5 minuti. - nonce: un valore univoco per prevenire attacchi di replay. - tag: un’etichetta che identifica lo scopo della firma (ad esempio, web-bot-auth).

Un esempio di Signature-Input potrebbe essere:

Signature-Input: sig1=("@authority" "signature-agent");keyid="z6MkqRYqQiSgvZQdnBytw86Qbs2ZWUkGv22od935YF4s8M7V";alg="ed25519";created=1711234567;expires=1711234867;nonce="abc123";tag="web-bot-auth"

La signature base La signature base è il testo esatto che viene firmato. Si costruisce concatenando i componenti coperti, ciascuno su una riga separata, nel formato:

"nome-componente": valore

Ad esempio, per una richiesta GET a https://www.esempio.it/pagina, la signature base potrebbe essere:

"@method": GET
"@authority": www.esempio.it
"signature-agent": https://bot.mio-sito.it

Il Generatore chiavi Web Bot Auth fornisce un esempio di signature base completa, che può essere usata come riferimento per implementazioni personalizzate. Un errore comune è includere spazi o caratteri aggiuntivi nella signature base, che causerebbero il rifiuto della firma. Ad esempio, un extra spazio dopo GET o una virgola mancante tra i componenti renderebbero la firma invalida.

Una volta costruita la signature base, questa viene firmata con la chiave privata Ed25519, e il risultato viene codificato in base64 e inserito nell’intestazione Signature. Il server che riceve la richiesta ricostruisce la signature base nello stesso modo, verifica la firma con la chiave pubblica e accetta la richiesta solo se tutto coincide.

La chiave privata generata dal Generatore chiavi Web Bot Auth è l’elemento più critico dell’intero sistema: se viene compromessa, chiunque può firmare richieste a nome del bot, vanificando l’intero meccanismo di autenticazione. Per questo motivo, è fondamentale adottare pratiche di conservazione sicure fin dal primo momento.

1. Generazione locale e mai trasmessa Il generatore crea la chiave privata direttamente nel browser tramite Web Crypto, senza inviarla a nessun server. Questo elimina il rischio di intercettazione durante la trasmissione, ma significa anche che la chiave scompare se si ricarica la pagina. È responsabilità dell’utente scaricare e conservare la chiave in un luogo sicuro prima di chiudere la scheda.

2. Formati di esportazione Il generatore offre due formati per la chiave privata: - JWK: un oggetto JSON contenente tutti i parametri, compreso il campo d (il segreto). Questo formato è utile per l’integrazione diretta con librerie JavaScript, ma richiede attenzione: il file non deve essere mai pubblicato o condiviso. - PKCS#8 PEM: una versione testuale della chiave, racchiusa tra -----BEGIN PRIVATE KEY----- e -----END PRIVATE KEY-----. Questo formato è compatibile con la maggior parte degli strumenti di crittografia (OpenSSL, librerie Python, ecc.) e può essere facilmente importato in gestori di segreti.

3. Dove conservare la chiave Ecco alcune opzioni, ordinate dalla meno alla più sicura: - File locale crittografato: salvare la chiave in un file protetto da password (ad esempio, con GPG o 7-Zip). Questa soluzione è semplice, ma vulnerabile a furti se il dispositivo viene compromesso. - Gestore di segreti locale: strumenti come KeePass o Bitwarden consentono di archiviare segreti in un database crittografato. Sono una buona scelta per chi gestisce poche chiavi. - Gestore di segreti cloud: servizi come AWS Secrets Manager, Google Secret Manager o HashiCorp Vault sono progettati per la gestione sicura di chiavi e credenziali. Offrono funzionalità avanzate come la rotazione automatica delle chiavi e l’accesso controllato tramite IAM. - Moduli hardware (HSM): per ambienti ad alta sicurezza, i moduli hardware come YubiKey o AWS CloudHSM proteggono le chiavi private all’interno di un dispositivo fisico, rendendole inaccessibili anche in caso di compromissione del server.

4. Rotazione delle chiavi Anche con la massima sicurezza, è buona pratica ruotare periodicamente le chiavi. Il campo exp nel directory delle chiavi pubbliche consente di impostare una data di scadenza, dopo la quale le firme generate con la vecchia chiave verranno rifiutate. Ad esempio, una chiave con "exp": [date=2024-06-30] scadrà automaticamente il 30 giugno 2024. Per ruotare una chiave: 1. Generare una nuova coppia di chiavi con il Generatore chiavi Web Bot Auth. 2. Pubblicare la nuova chiave pubblica nel directory, impostando una data di inizio validità (nbf) coincidente con la scadenza della vecchia chiave. 3. Aggiornare il codice del bot per usare la nuova chiave privata. 4. Lasciare scadere la vecchia chiave.

5. Errori da evitare - Pubblicare la chiave privata: il parametro d nel formato JWK o la sezione -----BEGIN PRIVATE KEY----- nel formato PEM non devono mai essere condivisi o caricati su repository pubblici. - Usare la stessa chiave per più bot: ogni bot dovrebbe avere una coppia di chiavi univoca, per consentire una revoca selettiva in caso di compromissione. - Conservare la chiave in chiaro: un file di testo non crittografato è un bersaglio facile per malware o accessi non autorizzati. - Ignorare la scadenza: una chiave senza exp rimane valida indefinitamente, aumentando il rischio di abuso se compromessa.

In sintesi, la sicurezza della chiave privata dipende da tre fattori: dove viene conservata, come viene protetta e con quale frequenza viene ruotata. Il Generatore chiavi Web Bot Auth fornisce gli strumenti per iniziare, ma la responsabilità finale è dell’utente.

Da decenni, i siti web si affidano a due metodi principali per identificare i bot: lo User-Agent e l’indirizzo IP. Entrambi hanno limiti evidenti, che il Web Bot Auth supera con un approccio crittografico. Vediamo perché la firma digitale è una scelta migliore.

1. User-Agent: facile da falsificare Lo User-Agent è una stringa di testo inviata dal client per identificarsi. Ad esempio, Googlebot si presenta come:

User-Agent: Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)

Il problema? Qualsiasi script può dichiarare di essere Googlebot con una semplice riga di codice. Basta impostare l’intestazione User-Agent su un valore arbitrario, e il sito non ha modo di verificare se la richiesta proviene davvero da Google o da un bot malevolo. Questo rende lo User-Agent un segnale debole, utile solo per statistiche, non per l’autenticazione.

2. Indirizzo IP: fragile e costoso Alcuni siti mantengono liste di indirizzi IP associati a bot legittimi (ad esempio, quelli di Google o Bing). Quando una richiesta arriva da uno di questi IP, viene accettata. Tuttavia, questo approccio presenta diversi problemi: - Scalabilità: mantenere liste aggiornate di IP è costoso, soprattutto per bot che usano reti distribuite (come i crawler di motori di ricerca). - Falsi positivi: un IP può essere riutilizzato da più servizi, portando a identificazioni errate. - Proxy e VPN: un bot malevolo può nascondersi dietro un proxy o una VPN, rendendo inutile la verifica dell’IP. - Costi operativi: le liste di IP richiedono aggiornamenti continui, e ogni errore può bloccare bot legittimi o consentire accessi non autorizzati.

3. Web Bot Auth: autenticazione crittografica Il Generatore chiavi Web Bot Auth risolve questi problemi con un meccanismo basato su firme digitali. Ecco i vantaggi: - Non ripudiabilità: una firma digitale non può essere generata senza la chiave privata. Se un bot firma una richiesta, non può negare di averla effettuata. - Verifica indipendente: il sito che riceve la richiesta verifica la firma confrontandola con una chiave pubblica pubblicata in un percorso standard (/.well-known/http-message-signatures-directory). Non c’è bisogno di liste di IP o User-Agent predefiniti. - Flessibilità: le chiavi possono avere una scadenza (exp) o una data di inizio validità (nbf), consentendo una rotazione sicura senza interruzioni. - Tracciabilità: ogni chiave ha un keyid univoco, che consente di distinguere tra bot diversi anche se usano lo stesso User-Agent.

4. Confronto diretto | Metodo | Affidabilità | Scalabilità | Costi operativi | Falsificabile | Tracciabilità | |----------------------|---------------|--------------|-----------------|---------------|---------------| | User-Agent | Bassa | Alta | Bassi | Sì | No | | Indirizzo IP | Media | Bassa | Alti | Sì (proxy) | Limitata | | Web Bot Auth | Alta | Alta | Bassi | No | Sì |

5. Quando usare i metodi tradizionali? Nonostante i vantaggi del Web Bot Auth, ci sono casi in cui i metodi tradizionali rimangono utili: - Robots.txt: definisce le regole di accesso per i bot (ad esempio, quali pagine possono essere crawlate). Il Generatore di robots.txt per crawler AI consente di creare file conformi alle specifiche. - Llms.txt: specifica quali contenuti possono essere usati per l’addestramento di modelli AI. Il Generatore di llms.txt aiuta a generare questo file. - Rate limiting: anche con l’autenticazione, è utile limitare il numero di richieste per IP o User-Agent per prevenire abusi.

In sintesi, il Web Bot Auth non sostituisce completamente i metodi tradizionali, ma li integra con un livello di autenticazione più robusto. Mentre lo User-Agent e l’IP rimangono utili per scopi informativi o per il rate limiting, la firma digitale offre una prova inconfutabile dell’identità di un bot, rendendola la scelta ideale per l’autenticazione vera e propria.

Come si configura il Web Bot Auth per il mio bot? Per iniziare, usa il Generatore chiavi Web Bot Auth per creare una coppia di chiavi Ed25519. Inserisci l’origine HTTPS che ospiterà il directory delle chiavi (ad esempio, https://bot.mio-sito.it) e un host di esempio (ad esempio, www.esempio.it). Scegli una durata per la chiave (nessuna scadenza, 30 giorni, 90 giorni o 365 giorni) e genera le chiavi. Scarica la chiave privata e pubblica il directory JSON nel percorso /.well-known/http-message-signatures-directory. Infine, firma ogni richiesta del bot con la chiave privata, includendo le intestazioni Signature e Signature-Input.

Il servizio è gratuito? Serve un account? Sì, il generatore è completamente gratuito e non richiede registrazione. Le chiavi vengono generate localmente nel browser tramite Web Crypto e non vengono mai trasmesse a nessun server. Questo garantisce la massima privacy, ma significa anche che le chiavi scompaiono se si ricarica la pagina: è responsabilità dell’utente scaricarle e conservarle in modo sicuro.

Cos’è il keyid e come viene calcolato? Il keyid è un identificativo univoco della chiave pubblica, calcolato come impronta SHA-256 della chiave in formato JWK (RFC 7638). Il risultato viene codificato in base64url e usato come valore del parametro keyid nelle firme. Ad esempio, se la chiave pubblica in JWK è:

{
  "kty": "OKP",
  "crv": "Ed25519",
  "x": "oB13Vqn5Z0JXZ1zZ1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Z1Y"
}

l’impronta SHA-256 di questo oggetto (ordinato alfabeticamente e senza spazi superflui) sarà il keyid. Questo valore consente ai siti di individuare rapidamente la chiave pubblica corretta nel directory.

Perché viene usato l’algoritmo Ed25519? Ed25519 è l’algoritmo di firma digitale raccomandato dalle specifiche IETF per le HTTP Message Signatures (RFC 9421). Offre diversi vantaggi: - Chiavi piccole: una chiave pubblica Ed25519 occupa solo 32 byte, contro i 64 byte di RSA-2048. - Firme veloci: la generazione e la verifica delle firme sono più rapide rispetto ad algoritmi come RSA o ECDSA. - Determinismo: le firme Ed25519 sono deterministiche, il che significa che la stessa chiave e lo stesso messaggio produrranno sempre la stessa firma, semplificando il debugging. - Sicurezza: Ed25519 è resistente a diversi tipi di attacchi crittografici, inclusi quelli basati su timing.

Cos’è la signature base e perché è importante? La signature base è il testo esatto che viene firmato con la chiave privata. Si costruisce concatenando i componenti coperti dalla firma, ciascuno su una riga separata, nel formato:

"nome-componente": valore

Ad esempio, per una richiesta GET a https://www.esempio.it/pagina, la signature base potrebbe essere:

"@method": GET
"@authority": www.esempio.it
"signature-agent": https://bot.mio-sito.it

La signature base è fondamentale per il debugging: se una firma viene rifiutata, confrontando la signature base generata dal proprio codice con quella di riferimento (fornita dal Generatore chiavi Web Bot Auth) si possono individuare errori di formattazione o componenti mancanti. Un errore comune è includere spazi aggiuntivi o caratteri non conformi, che renderebbero la firma invalida.

La mia chiave privata viene inviata al vostro server? No. Il Generatore chiavi Web Bot Auth crea la chiave privata direttamente nel browser tramite Web Crypto, una API JavaScript che esegue operazioni crittografiche localmente. La chiave non viene mai trasmessa a nessun server, né viene salvata in alcun database. Questo approccio garantisce la massima privacy, ma significa anche che le chiavi scompaiono se si ricarica la pagina. È responsabilità dell’utente scaricarle e conservarle in modo sicuro.

Ho ricaricato la pagina e la chiave è scomparsa. Cosa faccio? È normale: il generatore non salva nulla sul server né nel browser. Per recuperare la chiave, è necessario generarne una nuova e scaricarla immediatamente. Se hai perso la chiave privata, dovrai pubblicare una nuova chiave pubblica nel directory e aggiornare il codice del bot per usare la nuova chiave. Per evitare questo problema in futuro, conserva la chiave privata in un gestore di segreti o in un file crittografato.

Il mio browser non riesce a generare le chiavi o l’origine viene rifiutata. Perché? Il generatore richiede un browser moderno (Chrome, Firefox o Safari aggiornati) che supporti l’algoritmo Ed25519 tramite Web Crypto. Se il browser è obsoleto, non sarà possibile generare le chiavi. Inoltre, l’origine HTTPS inserita deve essere valida: non può contenere percorsi (ad esempio, https://bot.mio-sito.it/chiavi non è valido; deve essere https://bot.mio-sito.it). Assicurati anche che il sito sia raggiungibile tramite HTTPS, non HTTP.

Conviene scegliere una scadenza per la chiave o nessuna? Dipende dalle esigenze operative. Una chiave senza scadenza è più comoda, perché non richiede rotazioni frequenti, ma aumenta il rischio di abuso se la chiave privata viene compromessa. Una scadenza (ad esempio, 90 giorni) costringe a ruotare periodicamente le chiavi, migliorando la sicurezza, ma richiede una gestione più attenta. In generale, è consigliabile impostare una scadenza per chiavi usate in produzione, mentre per test o ambienti di sviluppo si può optare per nessuna scadenza.