---
pubDate = 2025-01-25T16:09:04
tags = ['https', 'web', 'nginx', 'linux', 'cryptographie']
lang = "fr"
type = "note"

[author]
name = "ache"
email = "ache@ache.one"

[[alt_lang]]
lang = "en"
url = "/notes/create_self-signed_certificate_from_a_self-signed_CA"
---

# Obtenir un certificat auto-signé à partir de sa propre autorité de certification

![Illustration d'un certificat auto-signé](res/certificat-signed-alt.svg)
Dans ce poste de blog, nous allons créer un certificat TLS autosigné, l'installer sur un serveur nginx et sur les systèmes clients.

## Objectifs de TLS

:::attention
Généralement, vous ne souhaitez pas avoir un certificat autosigné.
Si vous souhaitez obtenir un certificat valide sur internet, alors vous avez besoin qu'il soit validé par une autorité de certification.
Dans ce cas, [Let's Encrypt](https://letsencrypt.org/fr/) peut très certainement vous délivrer le certificat dont vous avez besoin.
:::

L'authentification TLS sert à **attester que le** serveur que vous souhaitez contacter (par son **nom de domaine**) **correspond bien au serveur** ayant autorité sur ce nom de domaine.
Cela peut paraître abstrait comme ça, mais il peut y avoir plusieurs raisons qui font que le nom de domaine ne redirige pas vers le bon serveur.

- Un DNS menteur
- Un routeur compromis vous redirige vers le mauvais serveur
- Une erreur de configuration (coté client ou serveur)
- ...

Ensuite, TLS se chargera du chiffrement qui assurera la confidentialité et l'intégrité.

TLS est un protocole utilisé comme surcouche à pleins d'autres protocoles (FTP, IMAP, SMTP, ..., et même DNS !) afin de leur rajouter une sécurité.

## Chaîne de certification (ou chaîne de confiance)

Nous n'avons pas la liste des certificats émis sur nos ordinateurs.
Ça serait trop compliqué à gérer, trop lourd, difficile à mettre à jour et au final peu fiable.[^ct-logs]

[^ct-logs]:
    C'est le rôle cependant des _Certification Transparency (CT) logs_ qui assurent que tout comportement suspect (au niveau de l'émission de certificat) puisse être détecté.
    Plus d'info à <https://certificate.transparency.dev/>.

<br><br>
<br><br>
<br><br>

<img src="res/chaîne_de_certification.png" class="big" alt="Schéma de la chaîne de certification">

Au contraire, on a une seulement une liste relative faible de certificats de confiance sur nos ordinateurs (149 chez moi).
Ce sont les certificats d'autorité, ou racines.
Ces certificats vont déléguer leur rôle de vérificateur d'identité à d'autres.
Ces autorités intermédiaires ont alors pour rôle de s'assurer que la demande de certification émane bien du bon serveur et d'émettre un certificat signé (et de courte durée, c'est-à-dire quelques jours, au plus quelques mois).

Dans notre cas, nous allons nous passez l'étape du certificat intermédiaire puisque nous n'allons jamais déléguer notre autorité.

:::info
Les certificats installés sur votre ordinateur sont sélectionnés par votre système d'exploitation (par exemple [celle de Windows](https://ccadb.my.salesforce-sites.com/microsoft/IncludedCACertificateReportForMSFT)).  
Souvent, celui-ci délègue votre confiance à un organisme de sélection de certificats comme [Mozilla](https://wiki.mozilla.org/CA/Included_Certificates).
:::

### Sous Arch Linux

Arch Linux utilise [p11-kit](https://github.com/p11-glue/p11-kit) pour gérer les certificats.

Tout comme sur les systèmes Ubuntu et Debian, la liste des certificats est disponible au format PEM dans le dossier `/etc/ssl/certs`.

OpenSSL est l'outil de référence en matière de TLS.
Vous pouvez l'utiliser pour afficher un certificat comme ceci.

```shell
$ openssl x509 -noout -text -in $certificat
```

Dans le cas d'un site web, on peut interroger le certificat d'un site web avec la commande suivante.

```shell
$ openssl s_client -connect ache.one:443 -verify_return_error </dev/null >/dev/null
Connecting to 2001:41d0:601:1100::11dc
depth=2 C=US, O=Internet Security Research Group, CN=ISRG Root X1
verify return:1
depth=1 C=US, O=Let's Encrypt, CN=R10
verify return:1
depth=0 CN=ache.one
verify return:1
DONE
```

On peut ajouter :

- `-showcerts` pour afficher le certificat serveur
- `-servername` pour mettre en place le SNI
- `-starttls` avec `smtp`, `ldap`, `pop3`, `xmpp`... pour vérifier l'installation TLS sur un serveur avec un protocole compatible StartTLS.
- On peut également extraire le certificat dans un fichier :

  ```shell
  $ openssl s_client -connect ache.one:443 -servername ache.one < /dev/null | \
            openssl x509 -outform PEM > ache_one.cert
  ```

- Vérifier les dates de validité du certificat :

  ```shell
  $ openssl x509 -in ache_one.cert -noout -dates # Pour un certificat que l'on possède localement
  notBefore=Wen 16 15:27:33 2025 GMT
  notAfter=Wen 30 15:27:33 2025 GMT
  $ openssl s_client -servername ache.one -connect ache.one:443 2>/dev/null </dev/null | \
            openssl x509 -noout -dates
  ```

## Créer le certificat racine

Premièrement, il faut créer une clé privée.
Nous allons utilisez RSA avec une clé de 3072 bits.

```shell
$ openssl genrsa -out root_ca.key 3072
```

Pour utiliser les courbes elliptiques, on utilisera plutôt `openssl ecparam -genkey` en sélectionnant une courbe parmi celles disponibles `openssl ecparam -genkey -list_curves` (attention à bien se renseigner sur le support de la courbe choisie).

Ensuite, on crée le certificat et on le signe :

```shell
$ openssl req -x509 -key local_ca.key -nodes -utf8 -days 3650 -out local_ca.cert -config local_ca.conf
```

Avec le fichier de configuration : 

```toml
[ req ]
default_bits        = 3072
distinguished_name  = x509_distinguished_name
x509_extensions = x509_ext
prompt = no

[ x509_distinguished_name ]
countryName		= "FX"
stateOrProvinceName	= Pays des bisounours
organizationName	= ache
organizationalUnitName	= ache
commonName = ache Root CA
emailAddress = ache@ache.one

[ x509_ext ]
basicConstraints=critical,CA:TRUE
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer:always
extendedKeyUsage=critical,serverAuth
subjectAltName=email:ache@ache.one,DNS:local,DNS:ache.local
# keyUsage = critical, digitalSignature, cRLSign, keyCertSign
keyUsage = critical, digitalSignature, keyEncipherment, keyCertSign
```

Ici, ce qui est important dans l'utilisation de `x509_extensions` plutôt que `req_extensions` et la ligne `basicConstraints` spécifiant `CA:TRUE`.

:::note
Il est possible de faire ces deux étapes en une seule commande :

```shell
$ openssl req -x509 \
            -sha256 -days 3650 \
            -nodes \
            -newkey rsa:3072 \
            -subj "/CN=ache Root CA/C=FR/L=La grande ville" \
            -keyout root_ca.key -out root_ca.cert
```

:::

On peut noter que généralement, il n'y a que 3 champs dans les certificats courants.

- `CN` : Common Name (comonName), le nom du certificat ou de l'authorité de certification;
- `O` : Organization(organizationName), le nom de la structure dont dépend l'authorité de certification;
- `C` : Country (countryName), le code pays sur 2 lettres de l'organisation.

Vous pouvez aussi ajouter (ou rencontrer) d'autres champs, mais c'est beaucoup plus rare.

- `OU` : Organizational Unit (organizationalUnitName), le nom de l'unité de l'organisation;
- `ST` : State or Province Name (stateOrProvinceName), le nom de l'état ou de la province;
- `E` : Email Address (emailAddress), l'adresse email de l'organisation.

Beaucoup d'autres champs sont disponibles, cf la [RFC 5280](https://datatracker.ietf.org/doc/html/rfc5280).

### Ajouter le certificat racine à la liste des certificats de confiance

Coté client, on peut d’ores et déjà installer le CA autosigné chez les clients.  
Pour des clients Arch Linux ça se fait alors avec la commande `trust`.

```shell
# trust anchor --store root_ca.cert
```

On peut vérifier qu'il est bien dans la liste à partir de son nom.

```shell
$ trust list | rg -C 2 "ache"
pkcs11:id=%F4%30%84%A6%0F%AD%AF%BB%6C%3A%2D%C6%1A%66%84%48%73%4E%CB%E7;type=cert
    type: certificate
    label: ache Root CA
    trust: anchor
    category: authority
```

:::warn
On en profite pour bien vérifier que le certificat est un certificat d'autorité (catégorie _authority_) et biensûr que ce soit bien un certificat (type _certificate_).
:::

Il est alors installé dans le dossier `/etc/ca-certificates/trust-source/`.
Pour supprimer le certificat des certificats de confiance, on utilise le fichier généré dans ce dossier.

```shell
# trust anchor --remove /etc/ca-certificates/trust-source/ache.dns.p11-kit
```

## Création du certificat DNS

Idem, on commence par créer une clé privée.

### La clé privée

```shell
$ openssl genrsa -out website.key 3072
```

Puis, on crée une **demande de signature**.
Celle-ci permet de configurer la signature par l'autorité de certification.

### La demande de signature

Normalement, dans le processus normal, le CA intermédiaire reçoit une demande de signature et initie alors le processus de vérification de l'identité du serveur qui demande la signature.

On peut le faire avec OpenSSL simplement :

```shell
$ openssl req -new -key website.key -out website.csr -utf8 -nameopt multiline,utf
```

:::info
Ici, j'ai rajouté les paramètres `-utf8 -nameopt multiline,utf8` afin d’accepter les caractères non ASCII dans les informations de certification (Nom de l'entreprise, de la région ...).
:::

OpenSSL va alors nous demander les informations de certification en mode interactif.
On peut éviter cela soit en remplissant les données directement en ligne de commande.

```shell
$ openssl req -new -out website.csr -sha256 -days 3650 -nodes -subj "/C=FR/ST=Centre/L=La grande Ville/O=NomDeLEntreprise/OU=/CN=CommonNameOrHostname"
```

Soit utiliser un fichier de configuration.
C'est ce que j'ai choisi de faire afin de facilité la recréation du certificat.

```shell
$ openssl req -new -key website.key -out website.csr -utf8 -nameopt multiline,utf8 -config website.conf
```

Le fichier de configuration ressemble à ceci : 

```toml
[ req ]
prompt = no
default_bits = 3072
default_md = sha256
distinguished_name = server_distinguished_name
req_extensions = v3_ext

[ server_distinguished_name ]
commonName = ache
countryName = FR
stateOrProvinceName = XXX
emailAddress = ache@ache.one
organizationName = ache local CA organization

[ v3_ext ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names

[ alt_names ]
DNS.0 = website.ache.one
DNS.1 = website_alt.ache.one
```

## Créer le certificat final

Il ne reste plus qu'à créer le certificat.
On a besoin pour cela de :

- La clé du certificat racine
- Le certificat racine
- La clé du certificat final
- La demande de signature

```shell
$ openssl x509 -req -CA ../root_ca/root_ca.cert -CAkey ../root_ca/root_ca.key -in website.csr -out website.cert -days 10 -CAcreateserial -extensions v3_ext -extfile website.conf -sha256
```

## Configuration du certificat dans nginx

Il n'y a rien de bien sorcier.
On rajoute `ssl` aux `listen` et on configure TLS.  
Pour cela, il faut indiquer où est la clé de chiffrement ainsi que le certificat.

```text
  listen [::]:443 ssl;
  listen 443 ssl;
  http2 on; # Not related to TLS

  ssl_certificate /srv/www/website.cert; # managed by myself !
  ssl_certificate_key /srv/website/cert/website.key;
  ssl_stapling off; # Since it's a self-signed certificate. No need for OCSP stapling.
  ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
```

On peut remarquer qu'il est possible de passer la chaîne de certificat également en concaténant le certificat final (en premier) avec le certificat racine.
Je ne sais pas si cela a un réel avantage, mais c'est une pratique courante.

Astuce: Vous pouvez configurer des certificats pour votre propre TLD.
Votre serveur sera ainsi accessible à l'adresse `https://TLD` (sans nom de domaine de second niveau).
C'est une pratique peu recommandée, mais qui marche.

## Mise à jour du certificat

Il est conseillé de mettre en place une méthode automatique de mise à jour du certificat.
Je recommande un timer systemd qui va vérifier la validité du certificat et le renouveler à intervalles réguliers.

`check-certificates.timer` :

```toml
# This timer unit is for refreshing local certificates everyday

[Unit]
Description=Refresh self-signed certificates regularly
Requires=check-certificates.service


[Timer]
Unit=check-certificates.service
OnUnitActiveSec=86400

[Install]
WantedBy=timers.target
```

Et `check-certificates.service`

```toml
# This service unit is for refreshing local certificates if needed

[Unit]
Description=Refresh local certificates if needed
Wants=check-certificates.timer

[Service]
Type=oneshot
ExecStart=/usr/bin/check-certificates.sh

[Install]
WantedBy=multi-user.target
```

J'ai ainsi créé un script bash pour automatiser la vérification des certificats et la mise à jour des fichiers de configuration de Nginx.

:::details

Contenue du fichier `check-certificates.sh`

::::summary

```bash
#!/bin/env bash

# This script checks the validity of the certificates in the directory
# ${CERTIFICATES_DIR} and renews them if necessary.
#
# It uses the local CA certificate and key to check the validity of the
# certificates in the directory ${CERTIFICATES_DIR}.
#
# The script is intended to be run from a systemd timer every day.


# TODO: Configure the following variables from cli arguments
# TODO: Rewrite this shit in Python
CERTIFICATES_DIR="/home/works/certs/"
LOCAL_CA_CERT="${CERTIFICATES_DIR}/local_ca.cert"
LOCAL_CA_KEY=$(echo "${LOCAL_CA_CERT}" | sed 's/.cert$/.key/')

HAS_RENEW_CERT=""
if [ ! -r "$LOCAL_CA_CERT" ]; then
  echo "☠️ Please re-check that local CA cert \"$LOCAL_CA_CERT\" exists"
  exit
fi
if [ ! -r "$LOCAL_CA_KEY" ]; then
  echo "☠️ Please re-check that local CA key \"$LOCAL_CA_KEY\" exists"
  exit
fi

date
echo -e "Checking certificate validity (NotAfter field)\n"

pushd ${CERTIFICATES_DIR} >/dev/null 2>/dev/null
for cert in $(find -name "*.cert"); do
  if openssl x509 -checkend 345600 -noout -in ${cert} > /dev/null; then
    echo -e "✔️ $(basename ${cert}) will expire in more than 4 days"
  else
    echo -e "❌ $(basename ${cert}) will expire soon !"
    if [ $(basename "$cert") = $(basename "$LOCAL_CA_CERT") ]; then
      echo -e "\t⛔ I don't renew local CA certificate"
      continue
    fi

    NEW_CSR=$(echo ${cert} | sed 's/.cert/.csr/')
    CERT_KEY=$(echo ${cert} | sed 's/.cert/.key/')
    CERT_CONFIG=$(echo ${cert} | sed 's/.cert/.conf/')

    echo "Renewing ${cert}"
    echo "Creating new CSR ($NEW_CSR)"
    echo ${cert}
    echo ${CERT_KEY}
    echo ${CERT_CONFIG}

    # Sign the new signing request
    if openssl req -new -key "${CERT_KEY}" -out "${NEW_CSR}" -config "${CERT_CONFIG}"; then
      echo "👍 CSR created"
    else
      echo "❌ Failled to create signing request!"
      continue
    fi

    echo "Renewing certificate"
    openssl x509 -req -CA "${LOCAL_CA_CERT}" -CAkey "${LOCAL_CA_KEY}" -in "${NEW_CSR}" -out "${cert}" -days 10 -CAcreateserial -extensions v3_ext -extfile "${CERT_CONFIG}" -sha256
    if [ $? -eq 0 ]; then
      HAS_RENEW_CERT="yes"
      echo "✔️ Certificate renew"
    else
      echo "❌ Failled to renew certificate!"
    fi
  fi
done

echo -e "\nNo more certificate to check"
if [ -n "$HAS_RENEW_CERT" ]; then
  echo "🔃 Reload nginx configuration (and update certificates)"
  nginx -s reload
fi

popd >/dev/null 2>/dev/null
```

::::