Installer et configurer Authelia pour Proxmox

19 mars 2025 à 12:16

Un mémo sur comment installer, configurer et intégrer Authelia à Proxmox pour l’authentification unique et à deux facteurs.

Présentation d’Authelia

Authelia est une solution d’authentification et d’autorisation open-source destinée à sécuriser l’accès aux applications web. Elle agit comme un reverse proxy d’authentification centralisé, offrant une gestion avancée des utilisateurs et des stratégies d’accès.
Principales fonctionnalités :

Authentification à deux facteurs (2FA) : Supporte TOTP, Duo, WebAuthn (FIDO2).
Intégration avec OpenID Connect : Permet l’authentification unique (SSO).
Gestion fine des accès : Basée sur les règles configurables (ACL).
Compatibilité avec les reverse proxies : Fonctionne avec Traefik, Nginx, Caddy, etc.
Stockage flexible : Supporte SQLite, PostgreSQL et MySQL pour la gestion des utilisateurs.
Déploiement facile : Disponible via Docker, Kubernetes et installation classique.
Cas d’usage

Sécuriser des services auto-hébergés (GitLab, Nextcloud, Home Assistant…)
Mettre en place un portail SSO centralisé pour plusieurs applications
Renforcer la sécurité des accès avec la double authentification

Informations globales et installation des dépendances nécessaires

Pour le mémo, voici les informations utilisées :

L’OS du serveur Authelia : Debian 12
L’installation d’Authelia se fait sans docker
Pas de serveur SMTP sur Authelia
nom d’hôtes :
- Serveur Proxmox : proxmox.local
- Serveur Authelia : authelia.local
Utilisateur de test :
- login: testuser
- Mot de passe : authelia
Installation des dépendances nécessaires :

apt install install nginx openssl apt-transport-https curl gnupg -y

Installation de Authelia via le dépôt

Importez la clé de signature :

curl -fsSL https://apt.authelia.com/organization/signing.asc | sudo gpg --dearmor -o /etc/apt/keyrings/authelia.gpg

Ajout du dépôt Authelia :

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/authelia.gpg] https://apt.authelia.com/stable/debian/debian all main" | sudo tee /etc/apt/sources.list.d/authelia.list > /dev/null

Mise à jour des dépôts :

apt update

Installation de Authelia :

apt install authelia -y

Configuration de Authelia

Configuration de base :
- Génération d’un certificat et d’une clé privé pour Authelia :
```
mkdir -p /etc/authelia/ssl
cd /etc/authelia/ssl
authelia crypto pair rsa generate
```

Création du fichier de configuration (attention, ici j’intègre de suite la partie client de Proxmox ) :

nano /etc/authelia/configuration.yml

---
# Configuration du serveur Authelia
server:
  address: "tcp://0.0.0.0:9091/"  # Écoute sur toutes les interfaces sur le port 9091

# Configuration des logs
log:
  level: debug  # Niveau de log : debug pour plus de détails

# Configuration de la validation d'identité
identity_validation:
  reset_password:
    jwt_secret: "ba820cfdc0c587eff1a23b96a3896ec7a076c384c09ad10bfc1b74788eea39631a4d9cfa22717645a396f5d45b18d632602e848ecb8c967b7854d5ebc4446b8a"  # Clé secrète pour le JWT utilisé dans la réinitialisation de mot de passe

# Configuration des sessions
session:
  name: authelia_session  # Nom du cookie de session
  same_site: lax  # Politique SameSite pour le cookie
  expiration: 1h  # Durée de vie de la session
  inactivity: 5m  # Temps d'inactivité avant expiration de la session
  remember_me: 1M  # Durée de la session en mode "Se souvenir de moi"
  secret: "8938ce8b853e74b35c05e0f10a904bd6ce4849d2aed8fb1b23b2916dd70c2af487a9ae5bf9672fa82411a3b171d351c08a0b75aa151939be45427174c26d5d60"  # Clé secrète pour la session
  cookies:
    - domain: "authelia.local"  # Domaine du cookie
      authelia_url: "https://authelia.local"  # URL d'Authelia
      same_site: lax  # Politique SameSite du cookie

# Configuration du contrôle d'accès
access_control:
  default_policy: deny  # Politique par défaut : refusé
  rules:
    - domain: "authelia.local"  # Domaine protégé
      policy: two_factor  # Exige une authentification à deux facteurs
    - domain: "proxmox.local"  # Domaine protégé
      policy: two_factor  # Exige une authentification à deux facteurs

# Backend d'authentification (fichier YAML)
authentication_backend:
  file:
    path: "/etc/authelia/users.yml"  # Chemin du fichier contenant les utilisateurs

# Configuration du TOTP (authentification à deux facteurs par application OTP)
totp:
  issuer: authelia.local  # Émetteur pour les codes OTP
  algorithm: sha256  # Algorithme utilisé pour le TOTP
  digits: 6  # Nombre de chiffres dans le code OTP
  period: 30  # Durée de validité du code en secondes
  skew: 1  # Tolérance de synchronisation en périodes
  secret_size: 32  # Taille du secret généré

# Configuration du fournisseur OpenID Connect
identity_providers:
  oidc:
    jwks:
      - key: |
          -----BEGIN PRIVATE KEY-----
          (clé privée pour la signature des tokens JWT. Voir plus bas  "Pour générer la clé privé de identity_providers")
          -----END PRIVATE KEY-----
    clients:
      - client_id: proxmox  # Identifiant du client OpenID Connect
        client_name: "proxmox.local"  # Nom du client
        client_secret: "$pbkdf2-sha512$310000$..."  # Secret du client (hashé)
        redirect_uris:
          - https://proxmox.local:8006  # URI de redirection après authentification
        scopes:
          - openid  # Activation du scope OpenID
          - profile  # Activation du scope profil
          - email  # Activation du scope email
        userinfo_signed_response_alg: none  # Réponse des infos utilisateur non signée
        require_pkce: false  # Désactive l'utilisation de PKCE
        authorization_policy: two_factor  # Exige une authentification à deux facteurs

# Configuration du stockage\storage:
  encryption_key: "ae5060901aaf3172cc87b896c92c30961b3734fc9a97be5c1da77b04dd4b754433f5cad3f679140d70ccc1a31743194231be04c5922dba34c275f89ac0bb42ce"  # Clé de chiffrement des données stockées
  local:
    path: "/var/lib/authelia/db.sqlite3"  # Utilisation d'une base de données SQLite pour le stockage local

# Configuration des notifications
notifier:
  filesystem:
    filename: "/var/log/authelia/notifications.txt"  # Fichier où sont stockées les notifications

Pour générer la clé privé de identity_providers :

authelia crypto pair rsa generate

cat private.pem

Pour jwt_secret, session.secret et encryption_key :

openssl rand -hex 64

Pour client_secret :

authelia crypto hash generate pbkdf2 --password toto

Créer un fichier de base de données utilisateur :

Pour commencer, créer un mot de passe chiffré :

authelia crypto hash generate --password authelia

Créer le fichier de configuration des utilisateurs :

nano /etc/authelia/users.yml

users:
  testuser:
    displayname: "Test User"
    password: "$argon2id$v=19$m=32768,t=1,p=8$eUhVT1dQa082YVk2VUhDMQ$E8QI4jHbUBt3EdsU1NFDu4Bq5jObKNx7nBKSn1EYQxk"

Pour vérifier la validation de la configuration :

authelia validate-config -c /etc/authelia/configuration.yml

Configuration parsed and loaded successfully without errors.

Création d’un service systemd

cp /tmp/authelia.service /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now authelia
systemctl status authelia

Pour avoir les journaux de logs en temps réel :

journalctl -u authelia -f

Configuration du serveur web d’Authelia

Attention, ici c’est une proposition de configuration nginx de base fonctionnelle

Génération du certificat SSL autosigné :

mkdir -p /etc/nginx/ssl
cd /etc/nginx/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout authelia.key -out authelia.crt -subj "/CN=authelia.local"
chmod 600 authelia.key authelia.crt

Créer le fichier de configuration du serveur web popur AUthelia :

nano /etc/nginx/site-enable/authelia.conf

server {
    listen 443 ssl;
    server_name authelia.local;

    ssl_certificate /etc/nginx/ssl/authelia.crt;
    ssl_certificate_key /etc/nginx/ssl/authelia.key;

    location / {
        proxy_pass http://localhost:9091;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
    }
}

# Redirection HTTP -> HTTPS
server {
    listen 80;
    server_name authelia.local;
    return 301 https://$host$request_uri;
}

test de la configuration :

nginx -t

Redémarrer le serveur web :

systemctl restart nginx

Configuration de la double authentification de Authelia avec TOTP

Sur le smartphone, installer l’application libre et open-source Aegis Authenticator -> https://f-droid.org/fr/packages/com.beemdevelopment.aegis/
Sur le PC, ouvrir le navigateur Internet et saisir l’URL du serveur Authelia :

Cliquer sur « Enregistrer l’appareil » :

Cliquer sur Ajouter :

Saisir le mot de passe à usage unique :

Mais je n’ai pas de serveur SMTP de configurer ???
Le mot de passe unique, se trouve dans /var/log/authelia/notifications.txt

cat /var/log/authelia/notifications.txt

Date: 2025-03-19 10:40:29.407130819 +0100 CET m=+5967.802203980
Recipient: {testuser testuser@example.com}
Subject: Confirm your identity
A ONE-TIME CODE HAS BEEN GENERATED TO COMPLETE A REQUESTED ACTION

Hi testuser,

This notification has been sent to you in order to verify your identity to
change security details for your account at authelia.local.

Do not share this notification or the content of this notification with anyone.

The following one-time code should only be used in the prompt displayed in your
browser.

--------------------------------------------------------------------------------

B6LAMWY4

--------------------------------------------------------------------------------

Une fois le code saisi, cliquer sur Suivant :

Avec l’application Aegis Authenticator, scanner le QR Code, puis cliquer sur suivant :

Pour confirmer, saisir le code temporaire afficher dans l’application Aegis Authenticator :

Le nouvel utilisateur a bien été ajouté à Authelia :

Intégration d’Authelia à Proxmox

Première chose, importer le certificat autosigné d’Authelia dans le magasin de certificat de Proxmox :

scp root@authelia.local:/etc/nginx/ssl/authelia.crt /usr/local/share/ca-certificates/

update-ca-certificates

Ouvrir Proxmox, puis Datacenter, Realms puis cliquer sur « Add »

Sélectioner OpenID Connect Server :

Renseigner comme suit :

Pour éviter l’erreur 401, ajouter de suite l’utilisateur testuser :

tester l’authentification sur Proxmox

Ouvrir Proxmox et sélectionner authelia comme système d’authentification :

Redirection vers le serveur Authelia, saisir le login et mot de passe :

La double authentification avec le code temporaire :

Accepter le consentement :

Et voilà, l’utilisateur testuser est connecté à Proxmox (évidemment, faudra configurer ses droits) :

Ressources

Je me suis aidé de ChatGPT, Mistral et Claude, mais aucun des trois n’a été totalement capable de m’aider.
La documentation officielle : https://github.com/authelia/authelia/tree/master/docs
Pour vérifier la configuration d’Authelia : https://www.authelia.com/reference/cli/authelia/authelia_config_validate/
Les commandes de chiffrement : https://www.authelia.com/reference/cli/authelia/authelia_crypto/
L’intégration dans Proxmox d’Authelia : https://www.authelia.com/integration/openid-connect/proxmox/
Pour le choix de l’application : https://www.authelia.com/reference/integrations/time-based-one-time-password-apps/
Pour récupérer le code sans serveur SMTP : https://www.simplehomelab.com/docker-authelia-tutorial/
Pour installer Authelia via les dépôts : https://blog.cyril.by/en/software/single-sign-on/installing-authelia-for-sso-all-in-one-guide

Vue normale