Vai al contenuto
GLGiuseppe Lanza Scrivimi

Certificati e chiavi con OpenSSL dal Mac

Chiavi private, CSR con SAN, verifica e conversione dei certificati, file .p12 compatibili con il Portachiavi, controllo di siti e scadenze dal Terminale del Mac.

Sistemi: macOS 13 Ventura – 26 Tahoe · Apple Silicon e IntelLivello: IntermedioTempo: 45 minutiAggiornata: novembre 2026

Quale OpenSSL c’è sul Mac

Dobbiamo chiedere un certificato per un server web, convertire quello ricevuto dall’ente di certificazione, preparare un .p12 per un firewall o per Windows: tutto si fa dal Terminale del Mac. Prima però verifichiamo che cosa abbiamo, come? Facile:

openssl version
which -a openssl
LibreSSL 3.3.6
/usr/bin/openssl

Il comando openssl incluso in macOS è in realtà LibreSSL, un derivato di OpenSSL mantenuto dal progetto OpenBSD (la versione cambia con gli aggiornamenti di macOS). Per quasi tutto il lavoro quotidiano va benissimo: chiavi, CSR, conversioni, .p12, verifica dei siti. Le differenze con OpenSSL 3 sono in qualche opzione, e le segnaliamo di volta in volta.

Se ci serve OpenSSL 3 (per esempio per seguire alla lettera la documentazione di un fornitore), lo installiamo con Homebrew:

brew install openssl@3
# Apple Silicon
/opt/homebrew/opt/openssl@3/bin/openssl version
# Intel
/usr/local/opt/openssl@3/bin/openssl version
# vale per entrambi
"$(brew --prefix openssl@3)/bin/openssl" version

Homebrew non sostituisce l’openssl di sistema: a seconda della configurazione, quello nuovo potrebbe non essere nel PATH, oppure precederlo. Prima di ogni lavoro importante controlliamo con which openssl e openssl version quale stiamo usando (consiglio: negli script indicate sempre il percorso completo). Negli esempi che seguono scriviamo openssl; dove il comportamento cambia tra LibreSSL e OpenSSL 3 lo diciamo.

Nomi di file d’esempio

Negli esempi usiamo server.key (chiave privata), server.csr (richiesta), server.pem (certificato), catena.pem (certificati intermedi) e server.p12. Lavoriamo in una cartella dedicata, per esempio ~/certificati/www.example.com.

La chiave privata

Per prima cosa occorre la chiave privata: è il segreto da cui dipende tutto, e non lascia mai il nostro computer (all’ente di certificazione mandiamo solo la richiesta). La forma storica, che funziona ovunque:

openssl genrsa -out server.key 2048

La forma moderna, con genpkey, è più flessibile e la preferiamo:

# RSA a 3072 bit
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out server.key
# curva ellittica P-256: chiave piccola e veloce, accettata da tutti i browser
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -out server-ec.key

Quale scegliere? RSA 2048 è ancora il minimo accettato; 3072 dà più margine. Le chiavi EC sono più leggere, ma qualche apparato datato (vecchi firewall, stampanti, sistemi embedded) accetta solo RSA: in caso di dubbio, RSA.

Proteggere la chiave

Una chiave leggibile da altri utenti è una chiave compromessa. Limitiamo subito i permessi:

chmod 600 server.key
ls -l server.key          # -rw-------

Ancora meglio, impostiamo i permessi prima di crearla, con umask 077 nella stessa sessione del Terminale. Possiamo anche cifrare la chiave con una passphrase; ricordiamo però che un server web o un firewall dovrà poi leggerla senza nessuno che digiti la password:

# chiave cifrata con AES-256 (la passphrase viene chiesta a terminale)
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -aes256 -out server.key
# togliere la passphrase quando il servizio la richiede in chiaro
openssl pkey -in server.key -out server-chiaro.key
chmod 600 server-chiaro.key

Non scriviamo le password nella riga di comando (con -pass pass:…): finirebbero nella cronologia della shell. Lasciamo che sia openssl a chiederle.

La richiesta di certificato (CSR)

La CSR contiene la chiave pubblica e i dati del titolare, firmati con la chiave privata. Senza argomenti, openssl chiede i campi uno per uno:

openssl req -new -key server.key -out server.csr

Più pratico passare tutto in una riga con -subj, e i nomi alternativi (SAN) con -addext. È un punto importante: i browser da anni ignorano il campo CN e guardano solo il subjectAltName, quindi il nome del sito deve stare lì.

openssl req -new -key server.key -out server.csr \
  -subj "/C=IT/ST=Liguria/L=Genova/O=Azienda Esempio/CN=www.example.com" \
  -addext "subjectAltName=DNS:www.example.com,DNS:example.com"

Il LibreSSL di macOS supporta -addext (verificato su macOS 26), come OpenSSL dalla 1.1.1. Per certificati con molti nomi, o per conservare la configurazione insieme alla chiave, un file è più comodo:

~/certificati/www.example.com/richiesta.cnf
[req]
prompt             = no
distinguished_name = dn
req_extensions     = estensioni

[dn]
C  = IT
ST = Liguria
L  = Genova
O  = Azienda Esempio
CN = www.example.com

[estensioni]
subjectAltName   = DNS:www.example.com, DNS:example.com, IP:192.0.2.10
keyUsage         = digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
openssl req -new -key server.key -config richiesta.cnf -out server.csr

Ora possiamo mandare server.csr all’ente di certificazione, oppure caricarlo nel pannello del fornitore. Non rimane che aspettare il certificato.

Un certificato autofirmato per il laboratorio

Per un NAS o un apparato interno, dove non serve un ente pubblico, possiamo generare direttamente un certificato autofirmato:

openssl req -x509 -new -key server.key -days 825 -out server.pem \
  -subj "/CN=nas.example.lan" \
  -addext "subjectAltName=DNS:nas.example.lan,IP:192.168.1.10"

Il browser lo segnalerà come non attendibile finché non lo aggiungiamo al Portachiavi come certificato fidato.

Leggere e verificare CSR e certificati

Prima di inviare una CSR controlliamola sempre: un errore nel nome costa un nuovo certificato.

openssl req -in server.csr -noout -text -verify

In cima deve comparire verify OK (la firma è valida); poi controlliamo Subject: e la sezione X509v3 Subject Alternative Name. Per il certificato ricevuto:

openssl x509 -in server.pem -noout -text                  # tutto
openssl x509 -in server.pem -noout -subject -issuer -dates
openssl x509 -in server.pem -noout -fingerprint -sha256
openssl x509 -in server.pem -noout -text | grep -A1 "Subject Alternative Name"

OpenSSL 3 ha anche -ext subjectAltName per stampare una sola estensione; il LibreSSL di macOS no, per questo usiamo grep.

La chiave corrisponde al certificato?

È il problema classico: tre file .key nella cartella e un certificato appena arrivato. Quale chiave è quella giusta? Confrontiamo la chiave pubblica contenuta in entrambi, ridotta a un’impronta:

openssl pkey -in server.key -pubout | openssl sha256
openssl x509 -in server.pem -noout -pubkey | openssl sha256
openssl req  -in server.csr -noout -pubkey | openssl sha256

Se le tre impronte coincidono, chiave, richiesta e certificato sono della stessa coppia. Questo metodo funziona con RSA e con EC. Il metodo tradizionale, solo per RSA, confronta il modulo:

openssl rsa  -in server.key -noout -modulus | openssl sha256
openssl x509 -in server.pem -noout -modulus | openssl sha256

La catena è completa?

openssl verify -CAfile catena.pem server.pem

server.pem: OK significa che il certificato è firmato dagli intermedi in catena.pem. Se il file contiene solo gli intermedi e non la radice, la verifica può fallire anche con una catena corretta: in quel caso aggiungiamo -untrusted catena.pem e passiamo la radice con -CAfile.

Convertire i formati

Lo stesso certificato può arrivare in forme diverse, e l’estensione del file non sempre dice la verità:

FormatoEstensioni tipicheCome si riconosce
PEM.pem, .crt, .cer, .keyTesto, inizia con -----BEGIN …-----
DER.cer, .der, .crtBinario (tipico degli ambienti Windows)
PKCS#7.p7b, .p7cSolo certificati (catena), senza chiave
PKCS#12.p12, .pfxBinario, chiave e certificati insieme, protetto da password

Il comando head -c 30 file.cer ci toglie il dubbio: se vediamo -----BEGIN CERTIFICATE----- è PEM, se vediamo caratteri illeggibili è DER.

# DER → PEM
openssl x509 -inform DER -in server.cer -out server.pem
# PEM → DER
openssl x509 -in server.pem -outform DER -out server.der
# PKCS#7 → PEM (tutti i certificati contenuti, uno dopo l'altro)
openssl pkcs7 -in catena.p7b -print_certs -out catena.pem
# se il .p7b è binario
openssl pkcs7 -inform DER -in catena.p7b -print_certs -out catena.pem

Molti server (nginx, per esempio) vogliono il certificato seguito dagli intermedi in un unico file: cat server.pem catena.pem > server-fullchain.pem.

Il file .p12 / .pfx

Il PKCS#12 mette insieme chiave privata, certificato e catena in un solo file protetto da password. È il formato che chiedono Windows, molti firewall e il Portachiavi del Mac.

openssl pkcs12 -export -out server.p12 \
  -inkey server.key -in server.pem -certfile catena.pem \
  -name "www.example.com"

La password di esportazione viene chiesta due volte. -name è l’etichetta che vedremo nel Portachiavi o nell’archivio certificati di Windows.

Il .p12 di OpenSSL 3 e il Portachiavi

Qui c’è una trappola che fa perdere tempo. OpenSSL 3 cifra il .p12 con algoritmi moderni (AES-256, PBKDF2, MAC con SHA-256). Il Portachiavi di macOS, almeno fino a macOS 26 compreso, non li accetta e risponde con un errore fuorviante:

security: SecKeychainItemImport: MAC verification failed during PKCS12 import (wrong password?)

La password è giusta: è l’algoritmo che non va. Lo stesso può capitare con apparati e sistemi più vecchi. Abbiamo tre soluzioni:

  1. usare il LibreSSL di sistema (/usr/bin/openssl): i suoi predefiniti sono gli algoritmi tradizionali (RC2 a 40 bit per i certificati, 3DES per la chiave, MAC con SHA-1), che il Portachiavi accetta;
  2. con OpenSSL 3, aggiungere -legacy, che attiva gli algoritmi tradizionali;
  3. con OpenSSL 3, indicare gli algoritmi uno per uno (funziona anche con LibreSSL, che invece non conosce -legacy):
"$(brew --prefix openssl@3)/bin/openssl" pkcs12 -export -out server.p12 \
  -inkey server.key -in server.pem -certfile catena.pem \
  -certpbe PBE-SHA1-3DES -keypbe PBE-SHA1-3DES -macalg sha1

Abbiamo provato le tre varianti con security import su macOS 26: il .p12 predefinito di OpenSSL 3 viene rifiutato, quello di LibreSSL e quello con 3DES e SHA-1 vengono importati. Le cose potrebbero cambiare con le prossime versioni di macOS: in caso di dubbio facciamo una prova di importazione prima di consegnare il file.

Algoritmi deboli, file da custodire

RC2-40 e 3DES con SHA-1 sono deboli: la sicurezza del .p12 dipende quasi tutta dalla password. Usiamone una lunga, trasmettiamola su un canale diverso dal file e cancelliamo i .p12 che non servono più. Per i sistemi che li accettano, gli algoritmi moderni di OpenSSL 3 restano la scelta migliore.

Per vedere come è stato costruito un .p12:

openssl pkcs12 -in server.p12 -info -noout

Estrarre chiave e certificati da un .p12

# solo il certificato del server
openssl pkcs12 -in server.p12 -clcerts -nokeys -out server.pem
# solo gli intermedi
openssl pkcs12 -in server.p12 -cacerts -nokeys -out catena.pem
# la chiave privata, cifrata (chiede una nuova passphrase)
openssl pkcs12 -in server.p12 -nocerts -out server.key
# la chiave privata in chiaro (OpenSSL 3 preferisce -noenc, -nodes funziona ancora)
openssl pkcs12 -in server.p12 -nocerts -nodes -out server.key
chmod 600 server.key

Il caso inverso della trappola di prima: un .p12 vecchio, esportato da Windows o da un apparato, aperto con OpenSSL 3 dà unsupported … Algorithm (RC2-40-CBC : 0). Aggiungiamo -legacy, oppure usiamo il LibreSSL di sistema, che lo legge senza problemi.

Importare nel Portachiavi

Il modo più semplice è il doppio clic sul file .p12 nel Finder: si apre Accesso Portachiavi, che chiede la password del file. Da Terminale:

security import server.p12 -k ~/Library/Keychains/login.keychain-db
security find-identity -v                # identità (certificato + chiave) disponibili
security find-certificate -c "www.example.com" -p   # il certificato in formato PEM

Senza l’opzione -P la password del file viene chiesta in modo interattivo; evitiamo di scriverla nel comando. Per un certificato senza chiave (per esempio la radice di una CA interna) basta security import radice.pem -k ~/Library/Keychains/login.keychain-db; per renderlo fidato lo apriamo in Accesso Portachiavi e impostiamo «Fidati sempre» nella sezione Attendibilità.

Verificare un sito e le scadenze

Che certificato presenta davvero un server? s_client si collega e ce lo mostra:

openssl s_client -connect www.example.com:443 -servername www.example.com

-servername invia il nome richiesto (SNI): senza, un server che ospita più siti può presentare il certificato sbagliato. Nell’output troviamo la catena inviata (Certificate chain), il certificato e, in fondo, Verify return code: 0 (ok) se tutto è in ordine. Il comando resta in attesa: si esce con Ctrl+C, oppure gli passiamo un input vuoto. Per avere solo le informazioni utili:

echo | openssl s_client -connect www.example.com:443 -servername www.example.com 2>/dev/null \
  | openssl x509 -noout -subject -issuer -dates
# tutta la catena inviata dal server
echo | openssl s_client -connect www.example.com:443 -servername www.example.com -showcerts 2>/dev/null

Lo stesso vale per altri servizi: -connect mail.example.com:993 per IMAP su TLS, oppure -starttls smtp sulla porta 587 (l’abbiamo visto nella guida Il Mac come console per apparati di rete).

Le scadenze

openssl x509 -in server.pem -noout -enddate
# scade entro 30 giorni (2592000 secondi)?
openssl x509 -in server.pem -noout -checkend 2592000 && echo "ok" || echo "IN SCADENZA"

-checkend restituisce un codice di uscita 0 se il certificato è ancora valido dopo l’intervallo indicato, 1 se scade prima: perfetto per uno script che controlla ogni mattina i nostri certificati. Un certificato scaduto è uno dei guasti più banali e più imbarazzanti: ne avevo parlato a proposito dei server di posta nella guida Rinnovare i certificati CA di Zimbra.

OperazioneComando
Versione in usoopenssl version, which -a openssl
Chiave RSAopenssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out server.key
Chiave ECopenssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -out server.key
CSR con SANopenssl req -new -key server.key -out server.csr -subj "/CN=…" -addext "subjectAltName=DNS:…"
Verificare la CSRopenssl req -in server.csr -noout -text -verify
Leggere un certificatoopenssl x509 -in server.pem -noout -text
Chiave e certificato corrispondonoopenssl pkey -in server.key -pubout | openssl sha256 e openssl x509 -in server.pem -noout -pubkey | openssl sha256
DER → PEMopenssl x509 -inform DER -in server.cer -out server.pem
P7B → PEMopenssl pkcs7 -in catena.p7b -print_certs -out catena.pem
Creare un .p12openssl pkcs12 -export -out server.p12 -inkey server.key -in server.pem -certfile catena.pem
.p12 compatibile da OpenSSL 3aggiungere -legacy oppure -certpbe PBE-SHA1-3DES -keypbe PBE-SHA1-3DES -macalg sha1
Estrarre dal .p12openssl pkcs12 -in server.p12 -clcerts -nokeys / -nocerts -nodes
Importare nel Portachiavisecurity import server.p12 -k ~/Library/Keychains/login.keychain-db
Certificato di un sitoopenssl s_client -connect host:443 -servername host
Scadenzaopenssl x509 -in server.pem -noout -enddate, -checkend 2592000

Problemi comuni

SintomoCausa e soluzione
MAC verification failed during PKCS12 import (wrong password?) importando nel Portachiavi.p12 creato da OpenSSL 3 con algoritmi moderni. Ricrearlo con /usr/bin/openssl, con -legacy o con -certpbe PBE-SHA1-3DES -keypbe PBE-SHA1-3DES -macalg sha1
unsupported … RC2-40-CBC aprendo un .p12File con algoritmi tradizionali letto da OpenSSL 3: aggiungere -legacy o usare LibreSSL
unknown option -legacyStiamo usando LibreSSL: non serve, i suoi predefiniti sono già quelli tradizionali
Il browser dice che il nome non corrispondeManca il subjectAltName o non contiene quel nome: rifare la CSR con -addext
Il server non parte: chiave e certificato non corrispondonoChiave sbagliata. Confrontare le impronte della chiave pubblica
unable to load certificate / Expecting: TRUSTED CERTIFICATEIl file è in DER: aggiungere -inform DER
I client segnalano una catena incompletaIl server non invia gli intermedi: usare il file con certificato e catena insieme; verificare con s_client -showcerts
Un comando trovato in rete non funzionaOpzione solo di OpenSSL 3 (per esempio x509 -ext): controllare openssl version e usare l’OpenSSL di Homebrew o un’alternativa

Il passo successivo

I certificati sono la base delle VPN: nella guida OpenVPN server su Ubuntu li generiamo con una piccola CA, e chi vuole il confronto con il passato trova il vecchio metodo con easy-rsa nella mia guida Una VPN con OpenVPN. Per provare i servizi cifrati sulle porte di posta e sugli apparati, torniamo a Il Mac come console per apparati di rete; per la diagnosi di rete che sta sotto, La rete dal Terminale del Mac.

Prima di andare in produzione

Prova sempre la configurazione in laboratorio, salva quella attuale prima di modificarla e tieni un accesso di emergenza (console o accesso fuori banda) quando lavori su firewall e VPN da remoto.