SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor · Aggiornato 2026-11-11

Aggiungere una CA personalizzata al trust store di Ubuntu

Crea una CA privata con openssl, firma un certificato leaf e installa la radice in /usr/local/share/ca-certificates per rendere attendibile HTTPS interno.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 15, 2026.

Aggiungere la propria CA al trust store di Ubuntu

Per aggiungere la propria CA al trust store di Ubuntu, copiare il certificato radice in /usr/local/share/ca-certificates/ usando un nome che termini con .crt, quindi eseguire sudo update-ca-certificates. Una CA (autorità di certificazione) è una coppia di chiavi il cui certificato può firmare altri certificati. Quando la macchina considera attendibile la propria radice, ogni certificato firmato da quella radice viene accettato. In questo modo, la verifica HTTPS tra i propri servizi non fallisce più.

Questa guida crea offline l'intera catena con openssl. Si crea una chiave radice e un certificato radice, si emette un certificato leaf per un server, quindi si installa la radice e si osserva come cambia il risultato dello stesso comando di verifica. L'ordine è importante: eseguire la verifica prima e dopo l'installazione mostra che è proprio l'installazione ad avere modificato il risultato.

Ubuntu 24.04 include OpenSSL 3 e il pacchetto ca-certificates nell'immagine predefinita, quindi non è necessario installare nulla prima (verificato ad agosto 2026).

Quando conviene gestire una CA propria?

Una CA pubblica come Let's Encrypt richiede un nome nel DNS pubblico e un server che possa raggiungere. I nomi interni non sono idonei. Un database su una rete privata o un pannello di amministrazione associato a un tunnel non può ottenere un certificato pubblico. Non va nemmeno esposto a Internet solo per ottenerne uno.

Un certificato autofirmato su Ubuntu risolve il problema per un solo host. Ogni client deve considerare attendibile quel certificato, e per l'host successivo occorre ripetere lo stesso lavoro. Una CA privata sposta la decisione a un livello superiore. I client considerano attendibile la root una sola volta. Da quel momento considerano attendibili tutti i certificati firmati dalla root, inclusi quelli per host che ancora non esistono.

Il costo è concreto. La chiave della root può firmare tutto ciò che i vincoli consentono. Chiunque riesca a leggere ca.key può quindi emettere certificati accettati dalle macchine. Proteggila come proteggeresti una chiave privata nella gestione delle chiavi SSH. Se un servizio dispone di un nome DNS pubblico, salta questa procedura e usa una CA pubblica: Certbot con nginx e Let's Encrypt richiede meno lavoro e non richiede l'installazione di nulla sul lato client.

Creare la chiave della CA e il certificato root

Lavorare in una directory accessibile solo dal proprio utente. La chiave root non deve mai uscire da questa directory.

install -d -m 700 ~/ca
cd ~/ca
openssl genrsa -aes256 -out ca.key 4096
chmod 600 ca.key

-aes256 cifra la chiave con una passphrase scelta dall'utente e tutti i comandi successivi che firmano con questa chiave devono specificarla. OpenSSL la richiede nel terminale, a meno che non venga fornita in un altro modo tramite -passin, che accetta un file o una variabile d'ambiente. Di conseguenza, qualunque posizione venga usata per l'automazione deve proteggere anche la chiave. Se si omette -aes256, la chiave resta memorizzata in chiaro sul disco. In questo caso è sufficiente un backup o un secondo account amministrativo per consentire a qualcuno di emettere certificati considerati attendibili dai propri sistemi.

Creare ora il certificato root, che la chiave della CA usa per firmare se stessa.

openssl req -x509 -new -key ca.key -sha256 -days 3650 \
  -subj "/O=Example Internal/CN=Example Internal Root CA" \
  -addext "basicConstraints=critical,CA:TRUE,pathlen:0" \
  -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -addext "subjectKeyIdentifier=hash" \
  -addext "nameConstraints=critical,permitted;DNS:internal.example" \
  -out ca.crt

Sostituire internal.example con il suffisso del nome effettivamente utilizzato e leggere la sezione successiva prima di mantenere quest'ultima estensione.

Ogni estensione ha una funzione specifica.

  • basicConstraints con CA:TRUE identifica questo certificato come certificato della CA. Senza questa impostazione, un client rifiuta qualsiasi certificato firmato da questa chiave, anche se la firma è corretta.
  • pathlen:0 indica che la CA può firmare certificati leaf, ma non altre CA subordinate.
  • keyUsage limita l'uso della chiave alla firma di certificati e liste di revoca. In questo modo la stessa chiave non può essere usata per errore come chiave di un server TLS.
  • subjectKeyIdentifier assegna alla CA un identificatore a cui fanno riferimento i certificati leaf. È così che un client individua l'emittente corretto in uno store che contiene alcune centinaia di certificati.
  • nameConstraints limita i nomi per i quali questa CA può attestare l'attendibilità.

Leggere nuovamente il contenuto creato, invece di presumere che il comando abbia eseguito ciò che si intendeva.

openssl x509 -noout -subject -issuer -serial -dates -in ca.crt
openssl x509 -noout -text -in ca.crt

Subject e issuer visualizzano la stessa stringa, perché un certificato root firma se stesso. Il numero di serie e le due date provengono dal file appena creato. Recuperarli quindi da questo output, non dalla guida di qualcun altro.

Limita ciò che la tua CA può firmare

Una CA root nell'archivio certificati del sistema è considerata attendibile per qualsiasi nome su Internet, salvo diversa indicazione. È un livello di autorità molto ampio da mantenere in un unico file su un unico server. nameConstraints lo riduce. Con permitted;DNS:internal.example nella root, una catena emessa da questa CA per un nome esterno a internal.example viene rifiutata, anche se la firma è valida.

Verifica questo comportamento senza considerare attendibile la CA.

openssl req -new -newkey rsa:2048 -nodes -keyout /tmp/outside.key -out /tmp/outside.csr \
  -subj "/CN=www.example.com"
openssl x509 -req -in /tmp/outside.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 30 -sha256 \
  -extfile <(printf 'subjectAltName=DNS:www.example.com\n') -out /tmp/outside.crt
openssl verify -CAfile ca.crt /tmp/outside.crt
echo $?

Il certificato viene emesso, perché la tua CA firma qualsiasi contenuto tu le chieda di firmare. Il controllo della catena è il punto in cui la verifica fallisce: lo stato di uscita è diverso da zero e OpenSSL indica il vincolo applicato. Questo è il valore dell'estensione. Anche una chiave privata della CA sottratta non può produrre un certificato funzionante per un nome esterno alla gerarchia. Al termine, elimina i file residui con rm /tmp/outside.*.

Prima di applicare un vincolo, devi conoscere quattro aspetti. È contrassegnato come critical, quindi un client che non comprende l'estensione deve rifiutare la catena invece di ignorarla. È il comportamento più sicuro, ma può creare problemi con una libreria TLS obsoleta. Una gerarchia consentita per i nomi DNS non limita i SAN con indirizzi IP, perché un tipo di nome per il quale non è stata elencata alcuna gerarchia resta senza restrizioni. Se i tuoi certificati contengono indirizzi IP, aggiungi permitted;IP:10.0.0.0/255.255.0.0 nella stessa estensione. La gerarchia deve includere ogni nome che potresti emettere, compresi i nomi host brevi. Di conseguenza, un certificato per il nome semplice app verrebbe rifiutato nell'esempio precedente. Infine, il vincolo è incorporato nel certificato root. Se cambi idea, devi creare un nuovo certificato root e installarlo nuovamente su ogni client.

Emettere un certificato leaf firmato dalla CA

Un certificato leaf è il certificato che un server presenta ai client. Iniziare dalla relativa chiave e da una CSR (certificate signing request), che contiene la chiave pubblica e il nome richiesto. La CSR è firmata dalla chiave leaf per dimostrare che il richiedente possiede la chiave privata corrispondente.

openssl req -new -newkey rsa:2048 -nodes \
  -keyout app.key -out app.csr \
  -subj "/CN=app.internal.example"
chmod 600 app.key

I nomi rilevanti devono essere inseriti in un file delle estensioni, non nella CSR. I client confrontano il nome host con subjectAltName (SAN). I browser e Go ignorano completamente il common name. I client che ricorrono ancora al common name, tra cui curl, lo fanno solo quando il certificato non contiene alcun SAN DNS o IP. Un certificato con CN ma senza SAN funziona quindi con alcuni strumenti e non con altri. Elencare pertanto ogni nome nel SAN e considerare il CN soltanto un'etichetta.

basicConstraints = CA:FALSE
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:app.internal.example, DNS:api.internal.example
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always

Salvare il file come app.ext, quindi firmare la richiesta con la CA.

openssl x509 -req -in app.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 397 -sha256 -extfile app.ext -out app.crt

-CAcreateserial scrive ca.srl accanto alla CA. Il file contiene il numero di serie successivo, in modo che due certificati emessi dalla stessa CA non condividano lo stesso numero. Conservare questo file nella directory della CA. -days 397 è una scelta, non un limite dello strumento. In questo contesto le durate brevi sono più importanti che con una CA pubblica, perché una CA privata non dispone di un'infrastruttura di revoca: non esistono una CRL o un responder OCSP se non vengono configurati. Di conseguenza, una chiave leaf divulgata resta utilizzabile fino alla scadenza del certificato.

Controllare il risultato prima di intervenire nell'archivio dei certificati attendibili.

openssl x509 -noout -subject -issuer -serial -dates -in app.crt
openssl x509 -noout -ext subjectAltName -in app.crt

La riga issuer ora indica la CA anziché il certificato leaf stesso. La riga SAN elenca i nomi per i quali il certificato è valido. Il client esegue il confronto con quell'elenco e con nient'altro.

Verifica con un -CAfile esplicito, prima di installare qualsiasi elemento

openssl verify -CAfile ca.crt app.crt
echo $?

Questa verifica pone una sola domanda: app.crt forma una catena fino al certificato in ca.crt? Non indica quali certificati siano considerati attendibili da questa macchina, perché hai passato la CA root a OpenSSL sulla riga di comando. Se la verifica non riesce, il problema riguarda i certificati stessi. Risolvilo prima di continuare.

Ora interroga la macchina.

openssl verify app.crt
echo $?

Senza -CAfile, OpenSSL usa la directory dei certificati integrata nella configurazione predefinita. openssl version -d stampa la directory di base usata dalla tua build e, su Ubuntu, la directory certs al suo interno corrisponde a /etc/ssl/certs. La tua root non si trova ancora lì, quindi la verifica non riesce: la catena raggiunge un emittente che l'archivio non contiene e non ci sono altre posizioni da controllare. Prendi nota del codice di uscita. È il valore che cambierà tra due passaggi.

Un client reale è un test migliore di openssl verify, perché controlla sia il nome host sia la catena. Avvia il certificato e recuperalo.

openssl s_server -accept 8443 -cert app.crt -key app.key -www &
curl --resolve app.internal.example:8443:127.0.0.1 https://app.internal.example:8443/

--resolve invia la connessione a 127.0.0.1 continuando però a richiedere app.internal.example, quindi il SAN corrisponde e l'unico aspetto ancora da verificare è l'attendibilità. curl non riesce e stampa il motivo per cui non ha potuto verificare la catena. Aggiungi -v per ottenere maggiori dettagli. Lascia il server di test in esecuzione.

Installare la CA root in /usr/local/share/ca-certificates

sudo cp ca.crt /usr/local/share/ca-certificates/example-internal-root.crt
sudo chmod 644 /usr/local/share/ca-certificates/example-internal-root.crt
sudo update-ca-certificates

I dettagli che determinano il corretto funzionamento sono i seguenti:

  • Il nome del file deve terminare con .crt. La pagina del manuale di update-ca-certificates specifica che i certificati con estensione .crt trovati sotto /usr/local/share/ca-certificates vengono inclusi e considerati attendibili implicitamente. Un file denominato root.pem o root.cer viene ignorato senza alcun messaggio.
  • Il contenuto deve essere in formato PEM, cioè il blocco codificato in base64 racchiuso tra le righe BEGIN CERTIFICATE e END CERTIFICATE. update-ca-certificates non esamina il contenuto del file. Di conseguenza, un file DER rinominato in .crt non viene ignorato: viene collegato in /etc/ssl/certs, i suoi byte grezzi vengono aggiunti al bundle che i client si aspettano contenga testo PEM e viene conteggiato come aggiunto. Controlla il file prima di copiarlo con openssl x509 -noout -subject -in ca.crt, che fallisce sull'input DER, e converti un file DER con openssl x509 -inform DER -in ca.der -out ca.crt.
  • Qui deve essere presente soltanto la root. La chiave privata della CA e il certificato leaf non devono trovarsi in un trust store.

update-ca-certificates stampa il numero di certificati aggiunti e rimossi. Se non ne ha aggiunto nessuno, la causa è l'estensione del nome file. Un conteggio pari a uno indica soltanto che ha trovato un file .crt, non che il file contenga un certificato utilizzabile. Conferma quindi la modifica dal punto di vista del sistema, non basandoti su quel messaggio.

ls -l /etc/ssl/certs/$(openssl x509 -noout -subject_hash -in /usr/local/share/ca-certificates/example-internal-root.crt).0
grep -c 'BEGIN CERTIFICATE' /etc/ssl/certs/ca-certificates.crt

Il primo comando costruisce un nome file a partire dall'hash del subject del certificato e lo elenca. update-ca-certificates ha creato quel link simbolico eseguendo openssl rehash e il link punta al file installato. Un file DER non supera questo controllo, perché openssl rehash non crea alcun link basato sull'hash per un file che non riesce a leggere come PEM. Il secondo comando conta i certificati presenti nel bundle costituito da un singolo file. Eseguilo anche prima dell'installazione, così puoi verificare che il numero aumenti di uno.

Quando copi questa CA root su altre macchine, verifica che la copia sia arrivata integra prima di installarla. Un certificato root è il file più rischioso del sistema da gestire in modo errato, quindi trattalo come qualsiasi altro download di cui verificare l’integrità con un checksum prima dell’uso. Le macchine Rocky Linux e AlmaLinux usano una directory diversa e update-ca-trust anziché update-ca-certificates per la CA root; per questi sistemi, segui invece aggiungere una CA su Rocky Linux e AlmaLinux.

Verifica nuovamente rispetto all’archivio certificati del sistema

openssl verify app.crt
echo $?
curl --resolve app.internal.example:8443:127.0.0.1 https://app.internal.example:8443/

Gli stessi comandi e gli stessi file di certificato producono una risposta diversa. Non è cambiato nulla in app.crt e il server è quello avviato in precedenza. L’unica differenza è che ora la CA radice si trova nell’archivio consultato da quei client, quindi la catena viene completata. Questo è il meccanismo da ricordare: la verifica cerca un emittente già considerato attendibile dal client e l’installazione di una CA inserisce l’emittente nel percorso consultato dal client.

Arrestare il server di test con kill %1.

Perché /etc/ssl/certs non è la directory in cui inserire il file

/etc/ssl/certs è un output generato. update-ca-certificates la riempie con collegamenti simbolici ai file dei certificati originali e scrive accanto a questi il bundle concatenato /etc/ssl/certs/ca-certificates.crt.

Un certificato copiato manualmente in questa directory non viene rilevato da alcun componente. La ricerca nelle directory di OpenSSL apre soltanto i file denominati in base all'hash del subject del certificato, quindi un file chiamato myca.crt non viene considerato. Su Ubuntu, curl legge il file bundle. Il bundle viene ricostruito a partire dalle origini registrate, quindi la copia manuale non viene inclusa neppure in questo percorso. update-ca-certificates --fresh rimuove i collegamenti che puntano alle due directory sorgente, insieme agli eventuali collegamenti non più validi, quindi ricrea soltanto quelli relativi al contenuto di tali directory.

L'altra parte della separazione è /usr/share/ca-certificates, che appartiene al pacchetto ca-certificates ed è elencato in /etc/ca-certificates.conf. Gli aggiornamenti del pacchetto lo riscrivono. /usr/local/share/ca-certificates è la directory riservata all'amministratore locale, quindi la CA resta disponibile dopo ogni aggiornamento del pacchetto che gestisce il resto.

Quali programmi ignorano l’archivio di attendibilità del sistema

L’installazione del certificato radice risolve il problema per tutti i programmi che usano OpenSSL o leggono /etc/ssl/certs. Rientrano in questa categoria curl, wget, git, il modulo standard ssl di Python e i programmi Go, che su Linux leggono i file di sistema. I runtime che includono un proprio elenco di certificati non vengono interessati. È questa la principale causa di confusione dopo un’installazione eseguita correttamente.

  • Node.js usa un elenco incorporato nel binario. Indica il certificato radice con NODE_EXTRA_CA_CERTS=/usr/local/share/ca-certificates/example-internal-root.crt e imposta la variabile nell’ambiente prima dell’avvio del processo, perché Node legge il valore una sola volta all’avvio. Le versioni attuali di Node includono anche un’opzione per leggere l’archivio di sistema; esegui node --help | grep -i system-ca per verificare se la tua versione la supporta.
  • La libreria requests di Python usa il bundle certifi. Imposta REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt per quel processo oppure passa verify="/etc/ssl/certs/ca-certificates.crt" alla chiamata. pip richiede --cert per lo stesso motivo.
  • Java legge un keystore. Su Ubuntu, il pacchetto ca-certificates-java installa un hook in /etc/ca-certificates/update.d/, quindi update-ca-certificates aggiorna anche il keystore Java quando il pacchetto è presente. In caso contrario, importa il certificato radice con keytool -importcert.
  • Firefox mantiene un proprio archivio e non legge mai /etc/ssl/certs. Importa il certificato dalle impostazioni dei certificati. Su Linux, Chromium legge un database NSS per utente, che puoi modificare con certutil del pacchetto libnss3-tools.
  • I container hanno un filesystem separato, quindi l’archivio del sistema host non ha alcun effetto al loro interno. Copia il certificato radice nell’immagine ed esegui update-ca-certificates durante la build. Tienine conto se i tuoi servizi vengono eseguiti con Docker Compose su un VPS.

Se dopo un’installazione corretta un programma continua a rifiutare il certificato, individua quali file apre prima di modificare altro. strace -f -e trace=openat <command> 2>&1 | grep -i cert è uno strumento diretto e nella maggior parte dei casi fornisce la risposta. Traccia solo le chiamate openat e il filtro nasconde tutti i bundle il cui percorso non contiene la parola cert. Se non stampa nulla, eseguilo di nuovo senza grep prima di concludere che il programma non legge alcun file. Questo è il comportamento tipico di un elenco incorporato nel binario.

Mantenere la CA utilizzabile nel tempo

La riemissione di un certificato leaf consiste nell’eseguire di nuovo il passaggio di generazione della CSR e quello di firma, usando lo stesso file app.ext. I client non devono eseguire alcuna operazione, perché la root di cui si fidano non è cambiata. Conservare ca.srl e ogni file .ext nella directory della CA, così la prossima emissione consisterà nel ripetere un comando già verificato, invece di ricostruire la procedura a memoria.

Eseguire il backup di ca.key e ca.crt in una posizione esterna alla macchina e mantenerli cifrati. Se si perde la chiave, non è possibile emettere nuovi certificati: è necessario creare una seconda CA e installarne la root ovunque sia stata installata quella precedente. Mantenere un elenco scritto di ogni macchina e di ogni archivio applicativo che ha ricevuto la root, perché questo elenco rende possibili la rotazione e la rimozione.

Quando la root si avvicina alla scadenza, generare in anticipo il certificato sostitutivo e installare entrambe le root una accanto all’altra. La presenza di due root nell’archivio non è un problema: un client accetta entrambe. Riemettere i certificati leaf usando la nuova root, quindi rimuovere quella precedente quando nessun componente dipende più da essa.

Rimuovere una CA dal trust store

sudo rm /usr/local/share/ca-certificates/example-internal-root.crt
sudo update-ca-certificates --fresh

--fresh rimuove i collegamenti simbolici in /etc/ssl/certs che puntano alle directory sorgente, compreso quello ormai spezzato dal file eliminato, e li ricrea usando le sorgenti ancora presenti. In questo modo, la radice eliminata viene rimossa sia dalla directory sia dal bundle. Verifica la rimozione con lo stesso metodo usato per verificare l’installazione.

openssl verify app.crt
echo $?
grep -c 'BEGIN CERTIFICATE' /etc/ssl/certs/ca-certificates.crt
ls -l /etc/ssl/certs/$(openssl x509 -noout -subject_hash -in ~/ca/ca.crt).0

La verifica fallisce di nuovo, il conteggio dei certificati torna al valore iniziale e il collegamento simbolico basato sull’hash non è più presente.

Il comando modifica il trust store di sistema e nient’altro. Annulla manualmente l’installazione in ciascuna delle altre posizioni: svuota NODE_EXTRA_CA_CERTS, elimina l’alias da ogni keystore Java, rimuovi la radice da ogni profilo del browser e ricrea ogni immagine container in cui era stata inclusa. La rimozione della radice non invalida i certificati che ha firmato. Restano validi su ogni macchina che continua a considerarla attendibile. Per questo, una CA privata deve avere un elenco scritto delle posizioni in cui è stata installata la radice. Una CA che non puoi revocare completamente costituisce una vulnerabilità permanente. Verifica quindi la rimozione su una macchina il giorno in cui configuri la CA, quando l’elenco è ancora breve.

FAQ

Dove si inserisce un certificato CA in Ubuntu?

In /usr/local/share/ca-certificates/, con un nome file che termina in .crt e contenuto PEM, quindi eseguire sudo update-ca-certificates. Questa directory è riservata all'amministratore locale, quindi gli aggiornamenti dei pacchetti non la modificano. /usr/share/ca-certificates appartiene al pacchetto ca-certificates, mentre /etc/ssl/certs viene generato a partire da entrambi; per questo un file inserito in una di queste directory viene sovrascritto o ignorato.

Perché curl rifiuta ancora il certificato dopo update-ca-certificates?

Esaminare le cause nell'ordine indicato. Il file potrebbe non terminare con .crt; in tal caso update-ca-certificates lo ignora e non aggiunge nulla. Potrebbe essere in formato DER anziché PEM, che lo strumento non rileva: collega comunque il file e lo aggiunge al bundle, conteggiandolo come aggiunto, ma non crea alcun collegamento hash. Convertirlo quindi in PEM, sostituire il file ed eseguire nuovamente il comando. Il subjectAltName del certificato potrebbe non contenere il nome host a cui ci si connette. Si tratta di un errore relativo al nome host, non di un errore di attendibilità. curl ricorre al common name solo quando il certificato non contiene alcun SAN DNS o IP; verificare con openssl x509 -noout -ext subjectAltName -in app.crt. Il server potrebbe inviare solo il certificato leaf, anche se è necessario anche un certificato intermedio. curl potrebbe utilizzare un bundle diverso a causa di CURL_CA_BUNDLE o --cacert. Inoltre, un servizio in esecuzione da lungo tempo deve essere riavviato, perché la maggior parte dei programmi legge il trust store una sola volta all'avvio.

Il trust store di sistema include Firefox, Chrome, Node e Java?

No. curl, wget, git, il modulo standard ssl di Python e i programmi Go leggono i file di sistema, quindi funzionano non appena viene eseguito update-ca-certificates. Firefox mantiene un proprio store. Chromium su Linux utilizza un database NSS per utente, modificato con certutil del pacchetto libnss3-tools. Node.js richiede NODE_EXTRA_CA_CERTS che punti al file della CA root. Java legge un keystore, che update-ca-certificates aggiorna solo quando è installato il pacchetto ca-certificates-java. Il requests di Python utilizza certifi e richiede REQUESTS_CA_BUNDLE.

Come si rimuove una CA dal trust store di Ubuntu?

Eliminare il file da /usr/local/share/ca-certificates/ ed eseguire sudo update-ca-certificates --fresh. L'opzione --fresh cancella i collegamenti simbolici in /etc/ssl/certs che puntano alle directory sorgente e li ricrea. In questo modo il certificato viene rimosso contemporaneamente dai collegamenti simbolici hash e dal bundle ca-certificates.crt. Verificare eseguendo openssl verify su un certificato firmato da quella CA e controllando lo stato di uscita. Ripetere quindi la rimozione in ogni altro store in cui il certificato era stato aggiunto, perché quel comando non interviene su nessuno di essi.

Posso usare una CA privata invece di Let's Encrypt per un sito pubblico?

No. Il browser del visitatore non ha mai visto la root, quindi mostra un avviso a pagina intera, e non è possibile installare la root sui computer che non si amministrano. Una CA privata è adatta ai nomi risolti soltanto dai propri computer e ai client amministrati direttamente. Per qualsiasi sito visitato da utenti esterni, ottenere il certificato da una CA pubblica.

Questo articolo ti è stato utile?

#tls#certificates#openssl#ubuntu#security#pki