Let's Encrypt

De ArchwikiFR

Let’s Encrypt est une autorité de certification gratuite, automatisée et ouverte qui utilise le protocole ACME.

Le client officiel est appelé Certbot, il autorise la récupération depuis la ligne de commande de certificats X.509 valides. Un client minimal avec la création manuelle de CSR (Certificate Signing Request) est disponible : acme-tiny. Pour les scripts il existe simp_le-git et letsencrypt-cli.

Installation

Installez le paquet certbot.

Des greffons sont disponibles pour l’installation et la configuration des certificats dans les serveurs web :

  • Un greffon expérimental pour Nginx est le paquet certbot-nginx.
  • Une installation automatique pour le serveur Apache peut être activée par le paquet certbot-apache.

Configuration

Consultez la page Certbot documentation pour plus d’informations sur la création et l’utilisation des certificats.

Webroot

Note :
  • La méthode Webroot requiert l’ouverture du port 80 en HTTP pour la validation de Certbot.
    • Pour valider Certbot avec HTTPS sur le port 443, les greffons Nginx (--nginx) ou Apache (--apache) doivent être utilisé au lieu de la méthode Webroot (--webroot).
  • Le nom du serveur doit correspondre à celui du DNS.
  • Les permissions peuvent avoir besoin d’être modifié pour permettre l’accès en lecture à http://domain.tld/.well-known.

Quand on utilise la méthode Webroot, Certbot place la réponse à un challenge qui sera utilisée pour la validation dans /path/to/domain.tld/html/.well-known/acme-challenge/.

L’utilisation de cette méthode est préférée par rapport à une installation manuelle, car elle offre un renouvellement automatique et une gestion des certificats simplifiées.

Astuce : La configuration Nginx suivante peut aider à obtenir un premier certificat :
/etc/nginx/servers-available/domain.tld

server {
  listen 80;
  listen [::]:80;
  server_name domain.tld;
  root /usr/share/nginx/html;
  location / {
    index index.htm index.html;
  }
}

# ACME challenge
location ^~ /.well-known {
  allow all;
  alias /var/lib/letsencrypt/.well-known/;
  default_type "text/plain";
  try_files $uri =404;
}

Obtenir un(des) certificat(s)

Requérir un certificat pour domain.tld en utilisant /var/lib/letsencrypt/ comme chemin accessible publiquement :

# certbot certonly --email email@example.com --webroot -w /var/lib/letsencrypt/ -d domain.tld

Pour ajouter un (sous-)domaine, en incluant tous les domaines enregistrés utilisés de la configuration actuelle :

# certbot certonly --email email@example.com --webroot -w /var/lib/letsencrypt/ -d domain.tld,sub.domain.tld

Pour renouveler l’intégralité des certificats :

# certbot renew

Pour une approche alternative voir #Renouvellement automatique.

À la main

Note :
  • Le serveur web doit être arrêté temporairement.
  • Le renouvellement automatique n’est pas disponible quand on utilise l’installation manuelle. Si vous en avez besoin, utilisez plutôt #Webroot.

Si aucun greffon n’est disponible pour votre serveur, utilisez la commande suivante :

# certbot certonly --manual

Si vous préférez utilisez un challenge DNS (enregistrement TXT) utilisez :

# certbot certonly --manual --preferred-challenges dns

Cela va automatiquement vérifier votre domaine et créer une paire certificat / clé privée. Cette paire sera placée dans /etc/letsencrypt/live/votre.domaine/.

Vous pouvez alors configurer manuellement votre serveur pour utiliser la clé et le certificat du dossier ci-dessus.

Note : Exécuter cette commande plusieurs fois va créer plusieurs ensembles de fichiers avec un nombre terminal dans /etc/letsencrypt/live/votre.domaine/. Prenez alors garde de soit les renommer dans le dossier, soit dans le fichier de configuration de votre serveur web.

Configuration avancée

Configuration du serveur web

Au lieu d’utiliser un greffon pour une configuration automatique, il peut être préférable d’activer SSL pour votre serveur à la main.

Astuce :
  • Mozilla a un article sur SSL/TLS qui inclut un outil automatique pour aider à la création d'une configuration sécurisée.
  • Cipherli.st fournit des exemples de configuration SSL forte et un tutoriel pour la configuration des serveurs modernes.

nginx

Un exemple pour le serveur domain.tld utilisant un certificat signé SSL de Let's Encrypt :

/etc/nginx/servers-available/domain.tld

# Redirection vers https
server {
  listen 80;
  listen [::]:80;
  server_name domain.tld;
  return 301 https://$host$request_uri;
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  ssl_certificate /etc/letsencrypt/live/domain.tld/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/domain.tld/privkey.pem;
  ssl_trusted_certificate /etc/letsencrypt/live/domain.tld/chain.pem;
  ssl_session_timeout 1d;
  ssl_session_cache shared:SSL:50m;
  ssl_session_tickets off;
  ssl_prefer_server_ciphers on;
  add_header Strict-Transport-Security max-age=15768000;
  ssl_stapling on;
  ssl_stapling_verify on;
  server_name domain.tld;
  ..
}

# Un  sous-domaine utilise le même certificat SSL :
server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  ssl_certificate /etc/letsencrypt/live/domain.tld/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/domain.tld/privkey.pem;
  ssl_trusted_certificate /etc/letsencrypt/live/domain.tld/chain.pem;
  ..
  server_name sub.domain.tld;
  ..
}

# ACME challenge
location ^~ /.well-known {
  allow all;
  alias /var/lib/letsencrypt/.well-known/;
  default_type "text/plain";
  try_files $uri =404;
}

Multiple domaines

La gestion de multiples domaines peut être facilitée par le mappage des requêtes HTTP de /.well-known/acme-challenge/ vers un unique dossier (comme /var/lib/letsencrypt).

Le chemin a besoin d'être inscriptible par le client Let's Encrypt et le serveur web (comme nginx ou Apache s'exécutant avec l'utilisateur http :

# mkdir -p /var/lib/letsencrypt/.well-known
# chgrp http /var/lib/letsencrypt
# chmod g+s /var/lib/letsencrypt

nginx

Créez un fichier contenant ce bloc location et incluez le dans le bloc server :

/etc/nginx/conf.d/letsencrypt.conf

location ^~ /.well-known {
  allow all;
  alias /var/lib/letsencrypt/.well-known/;
  default_type "text/plain";
  try_files $uri =404;
}

Exemple de la configuration d’un serveur :

/etc/nginx/servers-available/domain.conf
server {
  server_name domain.tld
   ..
  include conf.d/letsencrypt.conf;
}

Apache

Créez le fichier /etc/httpd/conf/extra/httpd-acme.conf:

/etc/httpd/conf/extra/httpd-acme.conf
Alias /.well-known/acme-challenge/ "/var/lib/letsencrypt/.well-known/acme-challenge/"
<Directory "/var/lib/letsencrypt/">
    AllowOverride None
    Options MultiViews Indexes SymLinksIfOwnerMatch IncludesNoExec
    Require method GET POST OPTIONS
</Directory>

Incluez le dans /etc/httpd/conf/httpd.conf:

/etc/httpd/conf/httpd.conf
Include conf/extra/httpd-acme.conf

Renouvellement automatique

systemd

Créez un service systemd appelé certbot.service:

/etc/systemd/system/certbot.service
[Unit]
Description=Renouvellement des certificats Let's Encrypt

[Service]
Type=oneshot
ExecStart=/usr/bin/certbot renew --quiet --agree-tos

Vous souhaitez de plus que votre serveur recharge les certificats après le renouvellement. Vous pouvez le faire en incluant ces lignes à votre fichier de service certbot.service :

  • Apache: ExecStartPost=/bin/systemctl reload httpd.service
  • nginx: ExecStartPost=/bin/systemctl reload nginx.service
Note : Avant de créer une horloge, vérifiez que votre service fonctionne correctement.

Ajoutez une horloge pour le renouvellement des certificats deux fois par jour et incluez un délai aléatoire pour que les renouvellements de tout le monde ne soit pas trop lourd pour le serveur Let's Encrypt (voir [1]) :

/etc/systemd/system/certbot.timer
[Unit]
Description=Renouvellement des certificats Let's Encrypt's deux fois par jour.

[Timer]
OnCalendar=0/12:00:00
RandomizedDelaySec=1h
Persistent=true

[Install]
WantedBy=timers.target

Activer et démarrez certbot.timer.

Services alternatifs

Quand vous utilisez la méthode seule, vous devez stopper vos serveurs avant d’exécuter la requête de renouvellement puis redémarrer votre serveur quand Certbot a finit de s’exécuter. Certbot fournit à ce sujet des crochets pour l'arrêt et le redémarrage automatique des serveurs.

nginx
/etc/systemd/system/certbot.service
[Unit]
Description=Renouvellement Let's Encrypt

[Service]
Type=oneshot
ExecStart=/usr/bin/certbot renew --post-hook "/usr/bin/systemctl restart nginx.service" --agree-tos
Apache
/etc/systemd/system/certbot.service
[Unit]
Description=Renouvellement Let's Encrypt

[Service]
Type=oneshot
ExecStart=/usr/bin/certbot renew --pre-hook "/usr/bin/systemctl stop httpd.service" --post-hook "/usr/bin/systemctl start httpd.service" --quiet --agree-tos

Voir aussi