====== Serveur d'authentification — Kanidm ======

Dernière mise à jour : juin 2026

===== Vue d'ensemble =====

Kanidm est le fournisseur d'identité centralisé de l'infrastructure. Il gère les comptes, les groupes, le login système des portables (via ''kanidm-unixd'' avec cache offline) et servira de backend LDAP pour les services web (Nextcloud, DokuWiki, etc.).

  * **Version :** 1.10.3
  * **Conteneur :** ''kanidm/server:latest''
  * **Accès web :** https://auth.beafrancois.fr
  * **Interface d'administration :** CLI uniquement (l'interface web est réservée au self-service utilisateur)

<code>
Portable (online)  --> kanidm-unixd --> Kanidm (auth + cache)
Portable (offline) --> kanidm-unixd --> cache local chiffré
Navigateur         --> auth.beafrancois.fr (self-service : mot de passe, MFA)
Service web (futur) --> LDAP --> Kanidm
</code>

===== Architecture réseau =====

<code>
Internet
   |  443
   v
[ Routeur OpenWrt ]  NAT 443 -> proxy
   |
   v  LAN1
[ Proxy Caddy ] 192.168.1.25
   |  reverse_proxy https://192.168.1.9:8443 (TLS interne auto-signé)
   v
[ Serveur Kanidm ] 192.168.1.9
   :8443  interface HTTPS (web + API)
   :3636  interface LDAPS (pour les services)
</code>

  * Le serveur Kanidm utilise un certificat **auto-signé** en interne
  * Caddy fait la terminaison TLS publique (Let's Encrypt) pour ''auth.beafrancois.fr''
  * Caddy accepte le certificat auto-signé de Kanidm via ''tls_insecure_skip_verify''

===== Configuration des machines annexes =====

==== DNS — OpenWrt ====

Une entrée DNS locale résout ''auth.beafrancois.fr'' vers l'IP du proxy Caddy (192.168.1.25), pour que la résolution fonctionne aussi sur le LAN.

==== Port forwarding — OpenWrt ====

  * Le port 443 est déjà forwardé vers le proxy Caddy (192.168.1.25)
  * La redirection pour l'accès externe à Kanidm sera activée **une fois la validation locale terminée**

==== Reverse proxy — Caddy ====

Sur le proxy, dans le ''Caddyfile'' (emplacement : ''/etc/caddy/Caddyfile'' dans le conteneur, projet dans ''/opt/proxy'') :

<code>
auth.beafrancois.fr {
    reverse_proxy 192.168.1.9:8443 {
        transport http {
            tls
            tls_insecure_skip_verify
        }
    }
}
</code>

Recharger Caddy après modification :

<code bash>
cd /opt/proxy
docker compose exec caddy caddy reload --config /etc/caddy/Caddyfile
</code>

==== Pare-feu — UFW (serveur principal) ====

Seul le proxy Caddy est autorisé à joindre Kanidm :

<code bash>
# Interface HTTPS
sudo ufw allow from 192.168.1.25 to any port 8443
# Interface LDAPS (pour les services web, ex. Nextcloud)
sudo ufw allow from 192.168.1.25 to any port 3636
</code>

===== Structure des fichiers =====

<code>
/mnt/stockage/docker/
├── compose/
│   └── auth/
│       └── docker-compose.yml
└── data/
    └── kanidm/
        ├── server.toml          ← configuration serveur
        ├── kanidm.db            ← base de données
        └── tls/                 ← certificats auto-signés
            ├── ca.pem
            ├── cakey.pem
            ├── cert.pem
            ├── chain.pem
            └── key.pem
</code>

===== docker-compose.yml =====

Emplacement : ''/mnt/stockage/docker/compose/auth/docker-compose.yml''

<code yaml>
services:
  kanidm:
    image: kanidm/server:latest
    container_name: kanidm
    restart: unless-stopped
    volumes:
      - /mnt/stockage/docker/data/kanidm:/data
    ports:
      - "192.168.1.9:8443:8443"
      - "192.168.1.9:3636:3636"
    environment:
      - RUST_LOG=info

networks:
  default:
    name: auth_net
</code>

===== server.toml =====

Emplacement : ''/mnt/stockage/docker/data/kanidm/server.toml''

<code toml>
domain = "beafrancois.fr"
origin = "https://auth.beafrancois.fr"
bindaddress = "0.0.0.0:8443"
ldapbindaddress = "0.0.0.0:3636"
db_path = "/data/kanidm.db"
tls_chain = "/data/tls/chain.pem"
tls_key = "/data/tls/key.pem"
log_level = "info"
</code>

**Permissions à appliquer** (sinon Kanidm émet des avertissements de sécurité) :

<code bash>
sudo chmod 750 /mnt/stockage/docker/data/kanidm
sudo chmod 640 /mnt/stockage/docker/data/kanidm/server.toml
sudo chmod 640 /mnt/stockage/docker/data/kanidm/tls/key.pem
sudo chmod 640 /mnt/stockage/docker/data/kanidm/tls/chain.pem
</code>

===== Mise en place initiale =====

==== 1. Générer les certificats TLS auto-signés ====

<code bash>
sudo mkdir -p /mnt/stockage/docker/data/kanidm/tls

docker run --rm -it \
  -v /mnt/stockage/docker/data/kanidm:/data \
  kanidm/server:latest \
  kanidmd cert-generate -c /data/server.toml
</code>

==== 2. Démarrer le serveur ====

<code bash>
cd /mnt/stockage/docker/compose/auth
docker compose up -d
docker compose logs -f kanidm
</code>

Attendre la ligne : ''ready to rock! 🪨 UI available at: https://auth.beafrancois.fr/''

==== 3. Initialiser les comptes break-glass ====

Deux comptes d'administration distincts (comptes de secours, pas pour usage quotidien) :

  * ''admin'' : gère la configuration de Kanidm (domaine, oauth2)
  * ''idm_admin'' : gère les personnes et les groupes

<code bash>
docker exec -it kanidm kanidmd recover-account admin -c /data/server.toml
docker exec -it kanidm kanidmd recover-account idm_admin -c /data/server.toml
</code>

Noter les mots de passe générés.

===== Client CLI =====

L'administration se fait via l'image séparée ''kanidm/tools''. Un wrapper simplifie les commandes.

==== Configuration client ====

Fichier ''~/.config/kanidm/config'' :

<code toml>
uri = "https://auth.beafrancois.fr"
verify_ca = false
</code>

==== Wrapper ====

Fichier ''~/kanidm-cli'' (rendu exécutable avec ''chmod +x'') :

<code bash>
#!/bin/bash
docker run --rm -it \
  --network host \
  -e KANIDM_URL="https://auth.beafrancois.fr" \
  -e KANIDM_VERIFY_CA="false" \
  --mount "type=bind,src=$HOME/.cache/kanidm_tokens,target=/root/.cache/kanidm_tokens" \
  kanidm/tools:latest \
  kanidm "$@"
</code>

**Note :** les variables d'environnement ''KANIDM_URL'' et ''KANIDM_VERIFY_CA'' sont utilisées car le montage du fichier de config dans le conteneur posait problème. Initialiser le cache de tokens avant la première connexion :

<code bash>
echo '{}' > ~/.cache/kanidm_tokens
chmod 666 ~/.cache/kanidm_tokens
</code>

==== Connexion ====

<code bash>
~/kanidm-cli login --name idm_admin
</code>

La session reste valide un certain temps ; inutile de se reconnecter à chaque commande.

===== Gestion des comptes et groupes =====

==== Groupes ====

<code bash>
# Créer un groupe
~/kanidm-cli group create famille --name idm_admin
~/kanidm-cli group create partage --name idm_admin
~/kanidm-cli group create multimedia --name idm_admin

# Lister les groupes
~/kanidm-cli group list --name idm_admin

# Ajouter des membres
~/kanidm-cli group add-members famille francois beatrice corentin louis --name idm_admin

# Lister les membres d'un groupe
~/kanidm-cli group list-members famille --name idm_admin
</code>

==== Personnes ====

<code bash>
# Créer une personne
~/kanidm-cli person create francois "François" --name idm_admin

# Activer l'extension POSIX (login système) avec UID/GID forcé
~/kanidm-cli person posix set francois --name idm_admin --gidnumber 1000

# Définir le mot de passe POSIX (login système / sudo)
~/kanidm-cli person posix set-password francois --name idm_admin
</code>

===== Comptes et groupes configurés =====

^ Groupe      ^ Rôle                          ^
| famille     | Accès commun aux 4 utilisateurs |
| partage     | Accès au partage ''/export/partage'' |
| multimedia  | Accès au partage ''/export/multimedia'' |

^ Utilisateur ^ UID/GID ^ Identifiant ^
| François    | 1000    | francois    |
| Béatrice    | 1001    | beatrice    |
| Corentin    | 1002    | corentin    |
| Louis       | 1003    | louis       |

Les UID/GID Kanidm sont **forcés pour correspondre aux UID locaux existants** sur les PC, ce qui garantit la cohérence de propriété des fichiers (notamment sur les partages NFS) et évite toute casse lors de la bascule.

===== Plan de bascule des PC (à faire plus tard) =====

Principe : ne jamais supprimer les comptes locaux avant validation complète de Kanidm.

  - **Compte de test** : créer ''testkanidm'' (UID 5000, n'existe sur aucun PC) pour valider le login online puis offline sans risque
  - **Installer ''kanidm-unixd''** sur un PC de test (Debian, Ubuntu ou Arch — paquets natifs ou AUR)
  - **Valider** le login online, puis couper le réseau et valider le login offline (cache)
  - **Bascule par PC** : pour chaque vrai utilisateur, ''userdel'' **sans** ''-r'' (préserve le home), Kanidm prend le relais. Les UID identiques garantissent la cohérence des fichiers
  - **Chiffrement disque** (LUKS) recommandé sur les portables : le cache offline stocke des credentials

===== Sécurité =====

  * Les comptes ''admin'' et ''idm_admin'' sont des comptes break-glass : usage exceptionnel uniquement
  * Kanidm exposé vers Internet (provisionnement portables hors LAN) → **MFA obligatoire** (TOTP ou passkey)
  * UFW limite l'accès à Kanidm au seul proxy Caddy
  * Forcer les UID/GID ne crée pas de faille (les UID ne sont pas des secrets). Seul risque classique Unix : la réutilisation d'UID sur des fichiers orphelins — théorique avec 4 comptes stables
  * **Auth des serveurs (principal + proxy) : ne PAS passer par Kanidm.** Garder un compte local + clé SSH, pour conserver l'accès même si Kanidm est indisponible

===== Commandes utiles =====

<code bash>
# État du conteneur
cd /mnt/stockage/docker/compose/auth
docker compose ps
docker compose logs -f kanidm

# Redémarrer
docker compose restart kanidm

# Mettre à jour
docker compose pull
docker compose up -d

# Reset d'un compte break-glass (nécessite accès exclusif à la DB)
docker exec -it kanidm kanidmd recover-account idm_admin -c /data/server.toml
</code>

====== Désactivation / suppression de Kanidm ======

Dernière mise à jour : juin 2026

**Contexte :** Kanidm est abandonné au profit de LLDAP + sssd, car l'authentification **hors ligne** (exigence fondamentale) ne fonctionne pas (auth refusée hors réseau malgré un credential caché — voir doc client Kanidm).

**Principe :** on **désactive et on sauvegarde**, on ne supprime pas définitivement tout de suite. La suppression réelle n'aura lieu qu'une fois LLDAP + sssd validé (offline inclus). Ça protège en cas de surprise avec la nouvelle solution.

===== Phase 1 — Désactivation (à faire maintenant) =====

==== Serveur ====

=== 1. Sauvegarder les données Kanidm ===

<code bash>
sudo tar czf ~/kanidm-backup-$(date +%F).tar.gz -C /mnt/stockage/docker/data kanidm
ls -lh ~/kanidm-backup-*.tar.gz
</code>

=== 2. Arrêter le conteneur ===

<code bash>
cd /mnt/stockage/docker/compose/auth
docker compose down
</code>

=== 3. Mettre le compose de côté (ne pas supprimer) ===

<code bash>
mv /mnt/stockage/docker/compose/auth/docker-compose.yml \
   /mnt/stockage/docker/compose/auth/docker-compose.yml.kanidm-disabled
</code>

=== 4. Retirer les règles UFW (ports 8443 et 3636 vers le proxy) ===

<code bash>
sudo ufw status numbered        # repérer les numéros des règles 8443 et 3636
sudo ufw delete <numero>        # supprimer chaque règle (du plus grand numéro au plus petit)
</code>

==== Proxy (Caddy) ====

=== 5. Retirer le bloc auth.beafrancois.fr du Caddyfile ===

Éditer le Caddyfile (commenter ou supprimer le bloc) :

<code>
# auth.beafrancois.fr {
#     reverse_proxy 192.168.1.9:8443 {
#         transport http {
#             tls
#             tls_insecure_skip_verify
#         }
#     }
# }
</code>

Puis recharger Caddy :

<code bash>
cd /opt/proxy
docker compose exec caddy caddy reload --config /etc/caddy/Caddyfile
</code>

==== Ce qu'on conserve (à réaffecter) ====

  * **Entrée DNS OpenWrt** ''auth.beafrancois.fr'' → garder, réutilisable pour la future stack d'auth (LLDAP/Authelia)
  * **Entrée DNS hébergeur** ''auth.beafrancois.fr'' → garder, idem
  * **Backup** ''~/kanidm-backup-*.tar.gz'' → conserver jusqu'à validation complète de LLDAP
  * **Wrapper** ''~/kanidm-cli'' → laisser (inoffensif, utile pour ré-exporter des données si besoin)
  * **Docs DokuWiki Kanidm** (serveur + client) → archiver, ne pas effacer (retour d'expérience utile)

==== Ce qu'on NE touche PAS encore ====

  * **Client kanidm-unixd sur les portables** → laisser actif. Sera désactivé proprement au moment d'installer sssd, pas avant (pour ne pas se retrouver sans auth).
  * **Comptes et groupes** → présents dans le backup, à recréer à l'identique dans LLDAP (UID 1000-1003 ; groupes famille, partage, multimedia).

===== Phase 2 — Suppression définitive (PLUS TARD, après validation LLDAP+sssd) =====

**⚠️ Ne faire ces étapes qu'une fois LLDAP + sssd pleinement validé, offline compris, sur tous les portables.**

==== Serveur ====

<code bash>
# Supprimer les données (le backup reste disponible si besoin)
sudo rm -rf /mnt/stockage/docker/data/kanidm

# Supprimer le dossier compose
rm -rf /mnt/stockage/docker/compose/auth

# Supprimer l'image Docker
docker image rm kanidm/server:latest

# Supprimer le wrapper CLI
rm -f ~/kanidm-cli
rm -rf ~/.config/kanidm ~/.cache/kanidm_tokens
</code>

==== Portables ====

<code bash>
# Désactiver et purger le client (APRÈS bascule vers sssd)
sudo systemctl disable --now kanidm-unixd kanidm-unixd-tasks
sudo apt remove --purge kanidm-unixd libnss-kanidm libpam-kanidm kanidm

# Nettoyer la config résiduelle
sudo rm -rf /etc/kanidm

# Vérifier nsswitch.conf : retirer 'kanidm' des lignes passwd/group
sudo nano /etc/nsswitch.conf

# Relancer pam-auth-update pour retirer le profil Kanidm
sudo pam-auth-update
</code>

==== Dépôt PPA (portables) ====

<code bash>
sudo rm -f /etc/apt/sources.list.d/kanidm_ppa.list
sudo rm -f /etc/apt/trusted.gpg.d/kanidm_ppa.asc
sudo apt update
</code>

==== DNS (une fois la nouvelle stack en place) ====

  * Réaffecter ou supprimer ''auth.beafrancois.fr'' selon le sous-domaine retenu pour LLDAP/Authelia
  * Supprimer le backup ''~/kanidm-backup-*.tar.gz'' une fois certain de ne plus en avoir besoin

===== Checklist rapide Phase 1 =====

  * [ ] Backup données Kanidm créé
  * [ ] Conteneur arrêté (''docker compose down'')
  * [ ] Compose renommé en ''.kanidm-disabled''
  * [ ] Règles UFW 8443 / 3636 retirées
  * [ ] Bloc Caddy ''auth.beafrancois.fr'' commenté + Caddy rechargé
  * [ ] DNS et backup conservés
  * [ ] Client portables et comptes laissés intacts