Certificati e PKIper Svogliati
Il lucchetto nel browser, il "non sicuro" sul NAS di casa, il certificato scaduto di domenica mattina. Dietro c'è sempre la stessa idea: qualcuno di cui ti fidi garantisce che una chiave appartiene a un nome. Capita quella, il resto sono comandi openssl.
"Clicca su Avanzate e poi Procedi comunque." — Il consiglio che ha insegnato a mezzo mondo a ignorare la sicurezza.
Da un'idea matematica a Let's Encrypt
Quarant'anni per passare da "i certificati costano e li hanno le banche" a "il certificato si rinnova da solo ogni due mesi, gratis".
La crittografia a chiave pubblica permette di cifrare con una chiave che chiunque può conoscere. Ma resta una domanda: questa chiave è davvero della mia banca, o di qualcuno che si spaccia per lei? Il certificato è la risposta: un documento firmato da una terza parte fidata che lega una chiave pubblica a un nome. La PKI (Public Key Infrastructure) è tutto quello che serve per far funzionare questa fiducia.
Diffie-Hellman, poi RSA
Whitfield Diffie e Martin Hellman pubblicano l'idea della chiave pubblica; l'anno dopo Rivest, Shamir e Adleman inventano RSA. La matematica c'è.
X.509
Lo standard che definisce com'è fatto un certificato. È ancora quello di oggi, alla versione 3.
SSL e il commercio online
Netscape crea SSL per comprare online in sicurezza. I certificati li vendono poche aziende, a centinaia di dollari l'anno.
DigiNotar
Una CA olandese viene bucata e qualcuno emette certificati falsi per Google, usati per spiare utenti in Iran. DigiNotar viene tolta dai browser e fallisce. Tutti capiscono che una sola CA compromessa basta a rompere il sistema.
Certificate Transparency
Ogni certificato pubblico deve finire in registri pubblici e verificabili. Da allora un certificato emesso di nascosto si scopre.
Let's Encrypt
Una CA gratuita e automatica, con il protocollo ACME (standardizzato nel 2019). In pochi anni la quota di siti in HTTPS passa dalla minoranza a quasi tutti.
Certificati sempre più brevi
La durata massima è scesa da anni a 398 giorni, e le CA hanno deciso di arrivare a 47 giorni entro il 2029. Rinnovare a mano non sarà più possibile: o è automatico, o si rompe.
Perché devi capirli
Perché "si è rotto l'HTTPS" è una delle chiamate più frequenti, e quasi sempre la causa è una di cinque.
La scadenza
Il rinnovo automatico si ferma in silenzio, e un giorno tutto il sito diventa "non sicuro". Con certificati da 47 giorni capiterà più spesso a chi non sorveglia.
La catena incompleta
Il browser funziona, curl e le app no. Manca il certificato intermedio: il più classico degli errori (sezione 4).
Il nome sbagliato
Il certificato è per www.example.com e qualcuno apre example.com. O per un nome interno che una CA pubblica non può darti.
I servizi interni
NAS, router, Proxmox, stampanti: tutti con il loro certificato self-signed e l'avviso rosso. Si può fare meglio (sezioni 10 e 11).
Non solo il web
Posta, VPN, database, MQTT, API tra servizi: tutto quello che usa TLS usa certificati, con gli stessi problemi.
Le chiavi private
Una chiave privata copiata in giro vale quanto il certificato stesso. Va trattata come una password, anzi meglio.
Quale certificato per quale cosa
Tre famiglie, tre usi. Sbagliare famiglia è l'origine di metà dei problemi.
| Voce | CA pubblica (Let's Encrypt e altre) | CA privata (tua) | Self-signed |
|---|---|---|---|
| Chi si fida | Tutti i browser e i sistemi | Solo chi ha installato la tua radice | Nessuno, senza un'eccezione a mano |
| Nomi possibili | Solo domini pubblici tuoi | Qualsiasi, anche .internal o un IP privato | Qualsiasi |
| Costo | Gratis (Let's Encrypt) o a pagamento | Gratis, ma la gestisci tu | Gratis |
| Va bene per | Tutto quello che è raggiungibile da Internet | Rete interna, laboratorio, certificati client, comunicazione tra servizi | Prove di cinque minuti |
| Rischio | Il nome finisce nei registri pubblici | Se perdi la chiave della radice, rifai tutto | Abitua tutti a cliccare "Procedi comunque" |
| Tipo di convalida | Cosa verifica la CA | Nota |
|---|---|---|
| DV (Domain Validation) | Che controlli il dominio | Let's Encrypt. È quello che usa quasi tutto il web |
| OV (Organization) | Anche che l'azienda esista | Il browser lo mostra uguale a un DV |
| EV (Extended) | Controlli più approfonditi sull'azienda | Una volta mostrava la barra verde; dal 2019 i browser non la mostrano più. Costa molto e non cambia niente per l'utente |
Il concetto chiave: la catena di fiducia
Il tuo browser non conosce il certificato del sito. Conosce qualcuno che conosce qualcuno che lo ha firmato.
Al confine nessuno conosce te. Conoscono però il Ministero che ha emesso il passaporto, e verificano timbri e firma. Il certificato radice (root) è il Ministero: pochi, conservati con cura, già presenti nel tuo sistema operativo e nel browser. La radice firma i certificati intermedi (le questure), che firmano il certificato del sito (il tuo passaporto). Il browser risale la catena fino a una radice che conosce. Se manca un anello, la catena si interrompe e il passaporto non vale niente.
| Anello | Dove sta | Chi lo manda |
|---|---|---|
| Radice (root CA) | Nel "trust store" del sistema o del browser | Nessuno: deve essere già lì. La sua chiave privata sta offline, in cassaforte |
| Intermedio | Firmato dalla radice | Il server, insieme al suo certificato |
| Foglia (il certificato del sito) | Firmato dall'intermedio | Il server |
Il server manda la catena, non solo il certificato
Configura sempre il file con certificato più intermedi (fullchain.pem). I browser a volte trovano l'intermedio da soli; curl, Python, Java e le app no.
Conta il SAN, non il CN
I nomi validi stanno nell'estensione Subject Alternative Name. Il vecchio campo CN da anni viene ignorato dai browser: un certificato senza SAN non vale.
La chiave privata non si sposta
Si genera dove verrà usata e lì resta. Alla CA va solo la richiesta (CSR), che contiene la chiave pubblica.
Anatomia di un certificato, e i suoi formati
Un certificato è un documento con pochi campi importanti. Il problema è che arriva in sei formati diversi con estensioni a caso.
Issuer: C=US, O=Let's Encrypt, CN=E6 # chi l'ha firmato (l'intermedio)
Validity
Not Before: Oct 1 08:12:44 2026 GMT
Not After : Dec 30 08:12:43 2026 GMT # la scadenza
Subject: CN=example.com
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey (P-256) # tipo di chiave
X509v3 Subject Alternative Name:
DNS:example.com, DNS:www.example.com # I nomi validi, gli unici che contano
X509v3 Basic Constraints: critical
CA:FALSE # non può firmare altri certificati
X509v3 Extended Key Usage:
TLS Web Server Authentication # a cosa serve
| Formato | Estensioni tipiche | Com'è fatto | Chi lo usa |
|---|---|---|---|
| PEM | .pem .crt .cer .key | Testo, tra -----BEGIN ...----- e -----END ...-----. Può contenere più certificati uno dopo l'altro | Linux, nginx, Apache, quasi tutto |
| DER | .der .cer | Lo stesso, in binario | Windows, Java, alcuni apparati |
| PKCS#12 | .p12 .pfx | Certificato, catena e chiave privata in un file solo, protetto da password | Windows, macOS, browser, certificati client |
| CSR | .csr | La richiesta da mandare alla CA: chiave pubblica e nomi, firmata con la chiave privata | Chi chiede un certificato a una CA |
.cer può essere PEM o DER. Aprilo con un editor di testo: se vedi -----BEGIN CERTIFICATE----- è PEM, se vedi caratteri strani è DER. Per le chiavi oggi conviene ECDSA P-256: più piccola e veloce di RSA a parità di sicurezza. RSA 2048 resta il minimo, e serve solo per client molto vecchi.
openssl: i comandi di tutti i giorni
openssl ha centinaia di opzioni. Questi dieci comandi coprono il lavoro vero.
# cosa c'è dentro un certificato
openssl x509 -in cert.pem -noout -subject -issuer -dates -ext subjectAltName
# cosa manda davvero un server (catena compresa)
openssl s_client -connect example.com:443 -servername example.com -showcerts </dev/null
# solo la scadenza del certificato di un server
echo | openssl s_client -connect example.com:443 -servername example.com 2>/dev/null | openssl x509 -noout -enddate
# posta: STARTTLS su SMTP
openssl s_client -connect mail.example.com:25 -starttls smtp </dev/null
# la chiave e il certificato sono una coppia? (le due righe devono essere uguali)
openssl x509 -in cert.pem -noout -pubkey | sha256sum
openssl pkey -in chiave.key -pubout | sha256sum
# la catena è valida?
openssl verify -CAfile radice.pem -untrusted intermedio.pem cert.pem
# chiave ECDSA P-256 e richiesta (CSR) con i nomi nel SAN
openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
-keyout chiave.key -out richiesta.csr -subj "/CN=example.com" \
-addext "subjectAltName=DNS:example.com,DNS:www.example.com"
# PEM → PKCS#12 (per Windows, macOS, un apparato che vuole un file solo)
openssl pkcs12 -export -in cert.pem -inkey chiave.key -certfile intermedio.pem -out pacchetto.p12
# PKCS#12 → PEM
openssl pkcs12 -in pacchetto.p12 -out tutto.pem -nodes
# DER → PEM
openssl x509 -inform der -in cert.cer -out cert.pem
-servername, s_client riceve quello di default, e ti convinci che il problema sia un altro.
Let's Encrypt e ACME
La CA chiede una prova che il dominio è tuo. Il client ACME la fornisce da solo, e rinnova da solo. Tu non fai niente: è il punto.
| Sfida | Come prova che il dominio è tuo | Serve | Quando |
|---|---|---|---|
| HTTP-01 | Mette un file in http://dominio/.well-known/acme-challenge/ | Porta 80 aperta da Internet | Il caso normale, un server web pubblico |
| DNS-01 | Crea un record TXT _acme-challenge.dominio | Le API del tuo DNS (Cloudflare, ecc.) | Certificati wildcard, server non raggiungibili da Internet, nomi interni |
| TLS-ALPN-01 | Risponde in modo speciale sulla porta 443 | Porta 443 e un client che lo supporta | Quando la porta 80 è chiusa (Caddy, Traefik lo usano da soli) |
| Client ACME | Per chi |
|---|---|
| certbot | Il classico, nei pacchetti di ogni distribuzione, plugin per nginx, Apache e molti DNS |
| acme.sh | Uno script shell senza dipendenze, supporta più di cento provider DNS |
| lego | Un binario Go, comodo nei container |
| Caddy, Traefik | Web server e proxy che fanno tutto da soli: scrivi il nome, il certificato arriva |
--test-cert in certbot): stessi passaggi, nessun limite, certificati non validi per i browser. Passa a quello vero solo quando tutto funziona.
certbot in pratica
Tre ricette: il sito normale, il wildcard via DNS, e il rinnovo che ricarica il servizio.
sudo apt install certbot
# webroot: certbot scrive la prova nella cartella del sito, nginx non viene toccato
sudo certbot certonly --webroot -w /var/www/html -d example.com -d www.example.com
# risultato in /etc/letsencrypt/live/example.com/:
# fullchain.pem → ssl_certificate (certificato + intermedi)
# privkey.pem → ssl_certificate_key
sudo apt install python3-certbot-dns-cloudflare
# token API di Cloudflare con il solo permesso Zone:DNS:Edit sulla zona giusta
echo 'dns_cloudflare_api_token = IL_TUO_TOKEN' | sudo tee /root/.cloudflare.ini
sudo chmod 600 /root/.cloudflare.ini
sudo certbot certonly --dns-cloudflare --dns-cloudflare-credentials /root/.cloudflare.ini \
-d example.com -d '*.example.com'
systemctl list-timers | grep certbot # su Debian il pacchetto installa già il timer
sudo certbot renew --dry-run # prova il rinnovo senza toccare niente
# dopo ogni rinnovo riuscito, ricarica chi usa il certificato
sudo tee /etc/letsencrypt/renewal-hooks/deploy/reload.sh >/dev/null <<'EOF'
#!/bin/sh
systemctl reload nginx
EOF
sudo chmod 755 /etc/letsencrypt/renewal-hooks/deploy/reload.sh
Durata, rinnovo, revoca e trasparenza
Le regole del gioco stanno cambiando, e vanno tutte nella stessa direzione: certificati brevi e tutto automatico.
| Da quando | Durata massima di un certificato pubblico |
|---|---|
| Fino al 2012 | Fino a 5 anni |
| 2015 | 39 mesi |
| 2018 | 825 giorni |
| 2020 | 398 giorni (circa 13 mesi) |
| Marzo 2026 | 200 giorni |
| Marzo 2027 | 100 giorni |
| Marzo 2029 | 47 giorni |
🚫 La revoca, in pratica
Un certificato si può revocare (chiave rubata, errore), ma controllare la revoca in tempo reale non ha mai funzionato bene: OCSP rallentava, si bloccava, raccontava alla CA quali siti visitavi. Let's Encrypt nel 2025 ha spento il suo servizio OCSP e usa solo le liste di revoca (CRL), che i browser scaricano in forma compressa. La vera risposta del settore è un'altra: certificati così brevi che la revoca serve poco.
🔎 Certificate Transparency
Ogni certificato pubblico finisce in registri pubblici. Effetto utile: su crt.sh vedi tutti i certificati emessi per il tuo dominio, e scopri subito se qualcuno ne ha chiesto uno a nome tuo. Effetto da sapere: anche i nomi dei tuoi server finiscono lì. vpn-interna.example.com non è più un segreto.
; solo Let's Encrypt può emettere certificati per questo dominio
example.com. IN CAA 0 issue "letsencrypt.org"
example.com. IN CAA 0 issuewild "letsencrypt.org"
example.com. IN CAA 0 iodef "mailto:security@example.com"
Nomi interni: il NAS senza l'avviso rosso
Una CA pubblica non può darti un certificato per nas.home o per 192.168.1.20. Le strade sono tre.
| Strada | Come | Pro | Contro |
|---|---|---|---|
| 1. Un sottodominio vero + DNS-01 | Usi nomi come nas.casa.example.com (un dominio tuo), il DNS di casa li risolve a IP interni, il certificato arriva con DNS-01 | Valido ovunque, nessuna radice da installare | Serve un dominio pubblico; i nomi finiscono nei registri CT (usa un wildcard *.casa.example.com per non elencarli uno per uno) |
| 2. Una CA privata | Crei la tua radice e la installi sui tuoi dispositivi (sezioni 11 e 12) | Qualsiasi nome, anche .internal e IP; niente nei registri pubblici | Ogni dispositivo deve fidarsi della tua radice; i telefoni sono i più ostinati |
| 3. Un reverse proxy davanti | Un nginx o Caddy con un certificato vero fa da porta d'ingresso a tutti i servizi interni | Un solo posto dove gestire i certificati | Un pezzo in più da tenere in piedi |
.home.arpa e .internal sono quelli riservati apposta (vedi DNS per Svogliati).
La tua CA privata
Due comandi openssl per capire come funziona. Uno strumento vero per usarla tutti i giorni.
# la radice: 10 anni, e può firmare SOLO nomi sotto casa.example.com e .internal
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
-keyout radice.key -out radice.crt -days 3650 -subj "/CN=Radice di casa" \
-addext "basicConstraints=critical,CA:TRUE" \
-addext "keyUsage=critical,keyCertSign,cRLSign" \
-addext "nameConstraints=critical,permitted;DNS:casa.example.com,permitted;DNS:internal"
chmod 400 radice.key # e poi lontano dal server, su un disco cifrato
openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
-keyout nas.key -out nas.csr -subj "/CN=nas.internal"
openssl x509 -req -in nas.csr -CA radice.crt -CAkey radice.key -CAcreateserial \
-out nas.crt -days 397 -extfile <(printf "subjectAltName=DNS:nas.internal\nextendedKeyUsage=serverAuth")
| Strumento | Cos'è | Quando |
|---|---|---|
| step-ca (Smallstep) | Una CA privata completa che parla anche ACME: i tuoi server usano certbot verso di lei come con Let's Encrypt | La scelta giusta per una rete interna vera: rinnovi automatici anche in casa |
| mkcert | Crea una radice locale, la installa sul tuo computer e firma certificati per lo sviluppo | Solo per sviluppare sul tuo PC. Mai in produzione |
| easy-rsa | Script attorno a openssl per gestire una piccola CA | OpenVPN e chi l'ha sempre usato |
| openssl a mano | I comandi qui sopra | Per capire, o per due certificati in un laboratorio |
nameConstraints la radice vale solo per i nomi che hai indicato: anche rubata, non può fingersi google.com. Mettilo sempre, e tieni la chiave della radice offline.
Distribuire la fiducia
Ogni sistema ha il suo elenco di radici fidate. Alcuni programmi ne hanno uno loro, e lì nasce il "sul browser va, nello script no".
| Dove | Come si aggiunge una radice |
|---|---|
| Debian / Ubuntu | Copia radice.crt (PEM, estensione .crt) in /usr/local/share/ca-certificates/, poi sudo update-ca-certificates |
| RHEL / Fedora | /etc/pki/ca-trust/source/anchors/, poi sudo update-ca-trust |
| macOS | Accesso Portachiavi → Sistema → importa, poi apri il certificato e imposta "Fidati sempre" |
| Windows | certlm.msc → Autorità di certificazione radice attendibili, o via criteri di gruppo |
| Firefox | Ha un elenco suo: importa nelle impostazioni, o, su Windows e macOS, attiva l'uso delle radici del sistema (security.enterprise_roots.enabled) |
| iPhone / iPad | Installa il profilo, poi Impostazioni → Generali → Info → Impostazioni attendibilità certificati → attiva |
| Android | Si installa come certificato utente, ma dalla versione 7 le app lo ignorano a meno che non lo dichiarino: di fatto funziona solo nel browser |
| Python (requests) | Usa il suo pacchetto certifi, non il sistema: REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt |
| Java | Ha il suo cacerts: keytool -importcert -cacerts -alias casa -file radice.crt |
| Container Docker | Non vedono le radici dell'host: copia la radice nell'immagine e lancia update-ca-certificates nel Dockerfile |
Sicurezza: oltre il lucchetto
Un certificato valido dice chi è il server. Non dice che la connessione è configurata bene.
✅ Fai
- Chiavi private
600, di proprietà di root o dell'utente del servizio - Solo TLS 1.2 e 1.3, configurazione da un modello affidabile (le linee guida Mozilla)
- HSTS, ma solo quando tutto il sito è in HTTPS da un po'
- Record CAA sui tuoi domini
- Un controllo della scadenza nel monitoraggio
- Certificati client (mTLS) per proteggere pannelli e API interne
❌ Non fare
- Chiavi private nei repository git, nelle email o nelle chat
- La stessa chiave su tutti i server "per comodità"
verify=False,curl -k,InsecureSkipVerifylasciati nel codice- Insegnare agli utenti a cliccare "Procedi comunque"
- HSTS con
preloadprima di essere sicuro: tornare indietro richiede mesi
server {
listen 443 ssl;
server_name pannello.example.com;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_client_certificate /etc/nginx/radice-client.crt; # la TUA CA privata
ssl_verify_client on; # niente certificato client, niente pagina
}
testssl.sh (open source, da riga di comando) o con il modulo SSL/TLS di NetForge, che ha anche un generatore di configurazioni per nginx, Apache e HAProxy dalle linee guida Mozilla e un decodificatore di certificati.
Errori tipici, tradotti
I messaggi cambiano da programma a programma. Le cause sono sempre le stesse sei o sette.
| Cosa vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
NET::ERR_CERT_AUTHORITY_INVALID | Il browser non conosce chi ha firmato: self-signed, o CA privata non installata | Installa la radice (sezione 12) o usa un certificato pubblico |
NET::ERR_CERT_COMMON_NAME_INVALID | Il nome aperto non è nel SAN del certificato | Aggiungi il nome al certificato. Ricorda: *.example.com non copre example.com né a.b.example.com |
NET::ERR_CERT_DATE_INVALID | Scaduto, oppure l'orologio del client è sbagliato | Rinnova e ricarica il servizio; se è solo un dispositivo, controlla la sua ora |
unable to get local issuer certificate / curl: (60) | Manca l'intermedio, o il client non conosce la radice | Server: usa fullchain.pem. Client: aggiorna le radici o aggiungi la tua |
| Nel browser va, nello script Python no | Python usa certifi, non le radici del sistema | REQUESTS_CA_BUNDLE o la radice dentro il bundle (sezione 12) |
PKIX path building failed (Java) | La radice non è nel cacerts di Java | keytool -importcert |
key values mismatch (nginx) | La chiave non è quella del certificato | Confronta le chiavi pubbliche (sezione 6) |
Let's Encrypt: Timeout during connect (likely firewall problem) | Sfida HTTP-01: la porta 80 non è raggiungibile da Internet | Apri la 80, o passa a DNS-01 |
Let's Encrypt: DNS problem: NXDOMAIN looking up TXT | Sfida DNS-01: il record TXT non c'è ancora o è nella zona sbagliata | Controlla il token API e attendi la propagazione |
Let's Encrypt: too many certificates already issued | Superato il limite settimanale | Aspetta, e la prossima volta prova con --test-cert |
| Certificato rinnovato, ma il sito mostra quello vecchio | Il servizio non è stato ricaricato | Deploy hook con il reload di tutti i servizi (sezione 8) |
| Su iPhone o Mac il certificato della CA privata non è accettato | Apple vuole SAN, uso "serverAuth" e durata non oltre 825 giorni anche per le CA private | Rifai il certificato con queste caratteristiche (la ricetta della sezione 11 le ha) |
Da dove continuare
Con certificati da 47 giorni l'unico rinnovo che funziona è quello a cui non pensi. Mettilo a posto adesso.
🗺️ Un percorso in quattro tappe
- Oggi: elenca i tuoi certificati e la loro scadenza. Cerca il tuo dominio su
crt.sh: scoprirai certificati che avevi dimenticato. - Questa settimana: rinnovo automatico ovunque, con
--dry-rune deploy hook. Un controllo di scadenza nel monitoraggio. - Poi: i servizi interni con un wildcard via DNS-01, o una CA privata con name constraints. Basta avvisi rossi.
- Dopo: record CAA, mTLS per i pannelli di amministrazione, step-ca se la rete interna cresce.
| Risorsa | Cos'è |
|---|---|
| letsencrypt.org/docs | Documentazione, tipi di sfida, limiti, novità |
| eff-certbot.readthedocs.io | Il manuale di certbot |
| crt.sh | Ricerca nei registri di Certificate Transparency |
| ssl-config.mozilla.org | Le configurazioni TLS consigliate per ogni server web |
| smallstep.com/docs/step-ca | La CA privata con ACME |
| testssl.sh | Controllo completo di un server TLS da riga di comando |
| DNS · Posta · Monitoraggio per Svogliati | Le guide da leggere insieme a questa |
openssl s_client -servername per vedere cosa manda davvero il server, e openssl x509 -noout -text per leggere cosa c'è scritto. Prima di cercare su Internet, guarda.