Certificati Self-Signed e OpenSSL
Published: 2024-03-21 13:32:58

---
title: Certificati Self-Signed e OpenSSL
published: true
date: 2023-11-09 00:00:00 UTC
tags: 
canonical_url: https://theredcode.it/devops/self-signed-certificati-openssl/
---

# Definizione

Un certificato _self-signed_ è un certificato SSL/TSL non firmato da un’autorità di certificazione pubblica o privata, che viene invece firmato dal certificato CA personale.

# Come funziona

Il modo per richiedere un certificato SSL/TLS a pagamento da una nota autorità di certificazione, come Verisign o Comodo, è il seguente:

- Creare una richiesta di firma del certificato (in inglese certificate signing request, abbreviato in CSR) con una chiave privata. Un CSR contiene dettagli su posizione, azienda e FQDN (ossia il nome di dominio completo);
- Inviare la CSR all’autorità CA attendibile;
- L’autorità (chiamata Certificate Authority, ossia CA) a cui abbiamo inviato la richiesta manderà indietro il certificato SSL firmato dall’autorità stessa e insieme a una chiave privata;
- A questo punto, sarà possibile quindi convalidare e utilizzare il certificato SSL con le diverse applicazioni.

Se invece parliamo di un certificato self-signed, abbiamo bisogno di rivedere gli step precedenti, tenendo conto che la CA sarà interna.

- Creare un’autorità locale e la chiave privata CA, e quindi prendere il posto della CA;
- Creare una chiave privata per generare la CSR;
- Creare un certificato SSL tramite la CSR utilizzando la nostra CA root e la chiave privata della CA;
- Installare il certificato dell’autorità nel browser o nel sistema operativo per evitare avvisi di sicurezza.

# Dove trovo le Certificate Authority del browser?

In Firefox, è sufficiente accedere alle “_Impostazioni_” e cercare la parola “_certificati_”: lì sarà presente una copia dei certificati che ogni sistema tiene a memoria di quelle che sono le autorità conosciute:

![](https://theredcode.it/img/firefox-certificates.png)

Allo stesso tempo, utilizzando un certificato self-signed, il browser genererà un avviso di sicurezza simile al seguente:

![](https://theredcode.it/img/self-signed-certificate-warning.png)

In ogni caso, è possibile forzare il browser ad accettare l’autorità di certificazione anche se creata, così da non vedere più nell’ambiente locale l’avviso di sicurezza una volta aggiunto all’elenco di quelli attendibili.

Chiaramente, è possibile anche condividere il certificato della CA con il team di sviluppo per installarlo anche nei loro browser, ma è un approccio che si consiglia di utilizzare solo su ambiente di test.

# Come creare un certificato self-signed

Il procedimento che seguiremo è descritto nella figura seguente:

![](https://theredcode.it/img/self-signed-schema.png)

Come discusso in precedenza, dobbiamo creare il **certificato principale della CA** affinché i browser possano fidarsi del certificato self-signed.

Creiamo una directory denominata _openssl_ per salvare tutte le chiavi e i certificati generati.

```
mkdir openssl && cd openssl

```

Esegui il seguente comando per creare il file _rootCA.key_ e il file _rootCA.crt_. Sostituisci a _example.com_ il tuo nome di dominio o l’indirizzo IP.

```
openssl req -x509 \
 -sha256 -days 356 \
 -nodes \
 -newkey rsa:2048 \
 -subj "/CN=exaple.com/C=US/L=San Francisco" \
 -keyout rootCA.key -out rootCA.crt

```

![](https://theredcode.it/img/self-signed-schema1.png)

Utilizzeremo questi due file per firmare il certificato self-signed a breve.

A questo punto, creiamo una **chiave privata** :

```
openssl genrsa -out server.key 2048

```

![](https://theredcode.it/img/self-signed-schema2.png)

Poi, iniziamo a lavorare alla **CSR** tramite un file _csr.conf_ che conterrà tutte le informazioni circa la richiesta da inviare all’autorità:

```
cat > csr.conf <<EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
req_extensions = req_ext
distinguished_name = dn

[dn]
C = US
ST = California
L = San Francisco
O = TheRedCode
OU = TheRedCode
CN = example.com

[req_ext]
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com
DNS.2 = www.example.com
IP.1 = 192.168.1.5
IP.2 = 192.168.1.6

EOF

```

![](https://theredcode.it/img/self-signed-schema3.png)

A questo punto, possiamo generare il file _server.csr_ per richiedere la **firma del certificato** tramite la chiave privata generata in precedenza con il seguente comando:

```
openssl req -new -key server.key -out server.csr -config csr.conf

```

Ora la cartella dovrebbe contenere tre file: _csr.conf, server.csr_ e _server.key_.

Eseguiamo quanto segue per creare il file _cert.conf_ per il certificato SSL.

```
cat > cert.conf <<EOF

authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = example.com

EOF

```

Infine, eseguiamo il comando seguente per generare il **certificato SSL firmato** tramite i file _rootCA.crt_ e _rootCA.key_ creati come parte della nostra autorità di certificazione.

```
openssl x509 -req \
 -in server.csr \
 -CA rootCA.crt -CAkey rootCA.key \
 -CAcreateserial -out server.crt \
 -days 365 \
 -sha256 -extfile cert.conf

```

![](https://theredcode.it/img/self-signed-schema4.png)

Il comando precedente genererà un file chiamato _server.crt_ che verrà utilizzato con la chiave privata _server.key_per abilitare il protocollo SSL.

Ad esempio, nel caso di un server come **Nginx** , nella configurazione potremo andare a inserire quanto segue per riportare i riferimenti ai due file appena creati:

```
server {

listen 443;

ssl on;
ssl_certificate /etc/ssl/server.crt;
ssl_certificate_key /etc/ssl/server.key;

server_name your.domain.com;
access_log /var/log/nginx/nginx.vhost.access.log;
error_log /var/log/nginx/nginx.vhost.error.log;
location / {
root /home/www/public_html/your.domain.com/public/;
index index.html;
}

}

```

![](https://theredcode.it/img/self-signed-schema5.png)

Non ci resta che installare la CA all’interno del _browser_ per evitare che il browser mostri il messaggio precedente quando verrà utilizzato il certificato self-signed, e il gioco è fatto!

**Nota** : come detto in precedenza, questa procedura dovrebbe riguardare i soli ambienti di sviluppo o test; nei casi d’uso in produzione, una valida alternativa gratuita è [Letsencrypt](https://letsencrypt.org/it/).