ajout du blog et de quelques articles

This commit is contained in:
tierce 2021-08-23 17:04:54 +02:00
parent dd94a2b077
commit 5c0104f4cd
12 changed files with 1525 additions and 94 deletions

View File

@ -8,9 +8,9 @@
## contenu à reprendre
* [ ] https://wiki.gnuragist.es/blog:en_couche
* [ ] https://wiki.gnuragist.es/documentation:borg
* [ ] https://wiki.gnuragist.es/documentation:gitea:ldap-ssl
* [x] https://wiki.gnuragist.es/blog:en_couche
* [x] https://wiki.gnuragist.es/documentation:borg
* [X] https://wiki.gnuragist.es/documentation:gitea:ldap-ssl
* [ ] https://wiki.gnuragist.es/documentation:gitea:remote-support-script
* [ ] https://wiki.gnuragist.es/notes:quoi-pour-qui
* [x] https://wiki.gnuragist.es/notes:certificate-renewal-fail
@ -19,6 +19,10 @@
* [ ] https://ps.zoethical.org/t/gnuragistes-dou-ca-vient-et-vers-ou-ca-va/3746
* [ ] https://ps.zoethical.org/t/gnuragistes-entre-benevolat-et-remuneration/3838
## makefile
Voir chez [tharyrok](https://gitlab.domainepublic.net/Tharyrok/tharyrok-eu/-/blob/master/Makefile) si besoin.
## Ressources
* [ForkAwsome cheatsheet](https://forkaweso.me/Fork-Awesome/cheatsheet/)

369
content/blog/borg.md Normal file
View File

@ -0,0 +1,369 @@
---
pagename: Borgmatic
title: Borgmatic
subtitle: Un outil pour gérer les sauvegarde
date: 2021-04-14
author: tierce
---
Mettre en place un serveur accessible en `ssh` et disposant d'un espace de stockage qui pourra accueillir les sauvegardes de différentes machines appartenant à l'un ou l'autre compte.
Les sauvegardes seront réalisées avec [borgmatic](https://torsion.org/borgmatic/) qui facilite la mise en place de [borg](https://borgbackup.readthedocs.io/en/stable/index.html).
```
NOM_DU_COMPTE = Une personne ou une assoss
NOM_DE_MACHINE = Une machine appartenant à NOM_DU_COMPTE
SERVEUR_BORG = Le serveur qui accueillera les sauvegarder
STOCKAGE_BORG = L'espace disque prévu pour les sauvegardes sur SERVEUR_BORG
PHRASE_DE_PASSE = La phrase de passe pour chiffrer et déchiffrer les sauvegardes d'une NOM_DE_MACHINE
CLE_SSH = Chemin vers une clé privée SSH
```
## Serveur
Le serveur peut-être un Debian récent disposant d'un accès `ssh`. Merci de veiller à ce que `root` ne puisse pas se connecter directement et de mettre en place un utilisateur qui aura un accès par clé ssh *(ed25519 si possible ou RSA4096)*. Cet utilisateur n'aura pas d'accès par mot de passe et n'aura pas le droit d'utiliser `sudo`.
### Installation
Borg est disponible dans les dépôts sur Debian.
```
apt install borgmatic
```
### Créer un compte
Le dossier `home` de chaque nouveau compte devrait se trouver sur `STORAGE`.
```
adduser --home /media/STORAGE/NOM_DU_COMPTE NOM_DU_COMPTE
```
### R/W sur storage pour l'utilisateur uniquement
Pour limiter les accès au `STORAGE` de `NOM_DU_COMPTE`.
```
chmod 700 /media/STORAGE/NOM_DU_COMPTE
```
## Machine
Un `NOM_DU_COMPTE` peut avoir plusieurs `NOM_DE_MACHINE` virtuelles ou non dont les sauvegardes seraient envoyées sur `NOM_DU_COMPTE@SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_DE_MACHINE`. Chacune de ces destinations /(repository ou repo)/ étant initiée avec son propre mot de passe et sa propre clé de chiffrement.
Depuis chaque `NOM_DE_MACHINE` c'est `root` qui se connectera sur `NOM_DE_COMPTE@SERVEUR_BORG` et il est donc nécessaire de générer une clé ssh /(ed25519 de préférence ou bien RSA 4096)* qui sera copiée sur le `SERVEUR_BORG` pour son `NOM_DE_COMPTE`.
### Faire une clé ecd25219 sans mot de passe
```
ssh-keygen -t ed25519 -C ""
et ne pas mettre de phrase de passe
```
### La copier sur le serveur borg
```
ssh-copy-id NOM_DU_COMPTE@SERVEUR_BORG
```
### Configurer le client SSH
Pour indiquer à SSH comment se connecter à `SERVEUR_BORG`
```
# nano ~/.ssh/config
Host SERVEUR_BORG
User NOM_DU_COMPTE
IdentityFile ~/.ssh/CLE_SSH
PreferredAuthentications publickey,password
```
### Installer borgmatic
```
apt install borgmatic
```
### Générer une config de base
```
generate-borgmatic-config
```
### Initier le repo sur le serveur
**Sans chiffrement**, Déconseillé.
**Avec chiffrement**, Voir [la documentation](https://borgbackup.readthedocs.io/en/stable/usage/init.html#borg-init)
```
# borg init --encryption=repokey-blake2 SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Passe phrase : PHRASE_DE_PASSE
```
```
# borg key export SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE /dev/stdout
BORG_KEY f6dc3da161fa259ad8c79380b2593d4996e4fb3c3efd802c88d996dd93b5f250
hqlhbGdvcml0aG2mc2hhMjU2pGRhdGHaAZ6DIeXAqvfULdYvWU6QooZHvmEaUvP3yzjQj9
l2I7xiDA/5rOjlP8kUFpefFtlMgo0gVcG8NQzqlZu8LQ/yFE3y52ldLc692D9Hr/rmrF+t
9wo7gvy33BaQmh+MrmbabipuJfm6p+u0lso11OJOwoX/GBXghL1lpazQnlERU1PqZZfiDe
ct6R1B67vdvQZXhVOuuYuLH9BNDMpq0eSc+9VHV3M/wFygmQtXfpcPTW2GekuQfSp9sk3D
a2pSFZs+wOMSZrx432DG5l/dbMXZgwmYgsMuixR2b+d/dNjSheMPy8tju2qCWL+ChbAm9A
oETPxAAOdBWUzxGgXPpnmuLxrjHf+XMpnt8E0fW6cqd/hdi2yuZJ0f7daZTVSM0KphHcP2
61JM+elY+xBFur8ibVekYllMC3Ot94DU/SYdAATxv8+X99tyB2UreGYxlwhCXUHNGba2XO
WWaDVNciAc1xc3sAX1gBVihEpZV4EbTPWkNj9DD3sWks9O0OeqTHdnhMVD1fpkKw2GDhfs
qb77w6DSwVZRnpgK58QwYDiTogukaGFzaNoAIIjMp6rDyIGoH+kxvLmOMq7w7/vzIL7PfO
wQvKVucuWuqml0ZXJhdGlvbnPOAAGGoKRzYWx02gAg0tq+i2wceA8guVTmn4AzKJsJRDb8
ueHXWCC+xBNhDNKndmVyc2lvbgE=
```
Et la coller dans le `password-store` du NOM_DU_COMPTE dans borg_sur_SERVEUR en tant que commentaire repokey-blake2 = "coller la clé".
### Éditer la config
```
nano /etc/borgmatic/config.yaml
# ceci est un exemple
location:
source_directories:
- /
repositories:
- SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
exclude_patterns:
- /dev
- /proc
- /sys
- /tmp
- /run
- /lost+found
- /swapfile
- /var/cache/apt
- /mnt/mmcboot
storage:
encryption_passcommand: secret-tool lookup borg-repository repo-name
encryption_passphrase: "PHRASE_DE_PASSE"
compression: lz4
retention:
keep_daily: 7
keep_monthly: 2
```
### Borg info
Depuis le client
```
borg info SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Et donner la PHRASE_DE_PASSE
```
Depuis le serveur
```
borg info /media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Et donner la PHRASE_DE_PASSE
```
### Borg mount
Depuis le serveur
```
mkdir /tmp/test
borg mount /media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
```
### Cron
```
nano /etc/cron.d/borgmatic
Et mettre :
42 0 * * * root /usr/bin/borgmatic --create --prune
42 1 * * 0 root /usr/bin/borgmatic --check
```
## Pour tator et les briques
Pour mettre en pratique ce qui est expliqué plus haut, voici ce qui se fait pour un cas particulier de **mabrique** et de **tator** qui sont deux Olimex LIME1 dans une cave connectées à Internet.
**mabrique** dispose d'une IP publique grâce à un [vpn de Neutrinet](https://neutrinet.be) et **tator** est sur le même réseaulocal *(LAN)*.
D'autre [briques internet](https://labriqueinter.net) viennent déposer leur sauvegardes `borgmatic` en passant *(jump)* par **mabrique** pour atteindre **tator**.
### Sur mon ordi
Créer un `password-store` avec [GoPass](https://woile.github.io/gopass-cheat-sheet/).
```
pass init --store NOM_DU_COMPTE
```
Et dans ce `password-store`:
créer un mot de passe pour `NOM_DU_COMPTE_sur_mabrique` dans `misc` avec comme commentaire `username = NOM_DU_COMPTE`.
créer un mot de passe pour `NOM_DU_COMPTE_sur_tator` dans `misc` avec comme commentaire `username = NOM_DU_COMPTE`.
créer un mot de passe pour `NOM_DEMACHINE_sur_tator` dans `misc` avec comme commentaire `repokey-blake2 = comming soon` pour y coller **plus tard** la clé obtenue depuis `NOM_DE_MACHINE` avec la commande `borg key export NOM_DU_COMPTE@SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE FICHIER_TEMP` /(voir plus haut)/.
### Sur mabrique
Créer un utilisateur pour `NOM_DU_COMPTE` avec le mot de passe créé précédemment.
```
adduser NOM_DU_COMPTE
```
Ce `NOM_DU_COMPTE` recevra la clé publique de `root` d'une `NOM_DE_MACHINE` /(cf. plus haut)/ qui devra envoyer ses sauvegardes.
Modifier la configuration de `ssh` pour autoriser le `saut ssh` vers `tator`. :!: Yunohost gère la configuration de `ssh`, donc cela va lever un warning pour le diagnostic automatique de Yunohost qui signalera que la configuration a changé.
```
nano /etc/ssh/sshd_config
Match User admin,root,NOM_DU_COMPTE, AUTRE_NOM_DU_COMPTE, etc.
AllowTcpForwarding yes
AllowStreamLocalForwarding yes
PermitUserRC yes
service ssh reload
```
### Sur tator
Il faut créer un utilisateur `NOM_DU_COMPTE` pour accueillir la clé de `root` de chaque `NOM_DE_MACHINE` ce qui permettra un accès `ssh` sans mot de passe.
```
adduser --home /media/STORAGE/NOM_DU_COMPTE NOM_DU_COMPTE
```
Et changer les droits du `home` pour ce NOM_DU_COMPTE.
```
chmod 700 /media/STORAGE/NOM_DU_COMPTE
```
### Sur une machine
Faire une clé ssh pour `root` sans mot de passe sur `NOM_DE_MACHINE` qui sera sauvegardée.
```
root@NOM_DE_MACHINE:/root# ssh-keygen -t ed25519
Generating public/private ed25519 key pair.
Enter file in which to save the key (/root/.ssh/id_ed25519):
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase): -ne rien mettre-
Enter same passphrase again: -ne rien mettre-
```
Ajouter `tator` et `mabrique` dans le `/root/.ssh/config` pour le proxy jump ssh.
```
# nano /root/.ssh/config
Host tierce
Hostname tierce.nohost.me
User NOM_DU_COMPTE
Host tator
Hostname 192.168.1.9
User NOM_DU_COMPTE
ProxyJump tierce
```
Copier la clé de `root` sur ma brique.
```
ssh-copy-id tierce
```
Copier la clé de `root` sur tator.
```
ssh-copy-id tator
```
Installer `borgmatic`.
```
apt install borgmatic
```
Créer une config de base pour borgmatic.
```
generate-borgmatic-config
```
Vérifier ce qui est monté pour éventuellement l'exclure des sauvegardes puisque ce qui sera sauvegardé c'est `/` /(tout le système)/ et que parfois, pour les briques qui sont sur un disque SATA ou USB par exemple, la carte SD avec l'ancien système est montée sur `/media/mmcboot`.
```
mount
et/ou bien:
df
et/ou bien:
ls /mnt
et/ou bien:
ls /media
```
Modifier le fichier de config de borgmatic.
```
nano /etc/borgmatic/config.yaml #voir exemple plus haut
```
Initier le repo borg pour NOM_DE_MACHINE.
```
borg init --encryption=repokey-blake2 tator:/media/STORAGE/NOM_DU_COMPTE/NOM_DE_MACHINE
```
Copier la clé de chiffrement dans le password store du client sur mon ordinateur.
```
# borg key export tator:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE /dev/stdout
BORG_KEY f6dc3da161fa259ad8c79380b2593d4996e4fb3c3efd802c88d996dd93b5f250
hqlhbGdvcml0aG2mc2hhMjU2pGRhdGHaAZ6DIeXAqvfULdYvWU6QooZHvmEaUvP3yzjQj9
l2I7xiDA/5rOjlP8kUFpefFtlMgo0gVcG8NQzqlZu8LQ/yFE3y52ldLc692D9Hr/rmrF+t
9wo7gvy33BaQmh+MrmbabipuJfm6p+u0lso11OJOwoX/GBXghL1lpazQnlERU1PqZZfiDe
ct6R1B67vdvQZXhVOuuYuLH9BNDMpq0eSc+9VHV3M/wFygmQtXfpcPTW2GekuQfSp9sk3D
a2pSFZs+wOMSZrx432DG5l/dbMXZgwmYgsMuixR2b+d/dNjSheMPy8tju2qCWL+ChbAm9A
oETPxAAOdBWUzxGgXPpnmuLxrjHf+XMpnt8E0fW6cqd/hdi2yuZJ0f7daZTVSM0KphHcP2
61JM+elY+xBFur8ibVekYllMC3Ot94DU/SYdAATxv8+X99tyB2UreGYxlwhCXUHNGba2XO
WWaDVNciAc1xc3sAX1gBVihEpZV4EbTPWkNj9DD3sWks9O0OeqTHdnhMVD1fpkKw2GDhfs
qb77w6DSwVZRnpgK58QwYDiTogukaGFzaNoAIIjMp6rDyIGoH+kxvLmOMq7w7/vzIL7PfO
wQvKVucuWuqml0ZXJhdGlvbnPOAAGGoKRzYWx02gAg0tq+i2wceA8guVTmn4AzKJsJRDb8
ueHXWCC+xBNhDNKndmVyc2lvbgE=
```
Simuler une sauvegarde
```
borgmatic -n -v2
```
Planifier la sauvegarde.
```
nano /etc/cron.d/borgmatic
et coller:
42 0 * * * root /usr/bin/borgmatic --create --prune #ou 42 est la minute et 00 l'heure de début * * * étant chaque jour, chaque mois, chaque jour de la semaine
42 1 * * 0 root /usr/bin/borgmatic --check
```
----
## À suivre
### ?? stockage chiffré monté au boot
### ?? postgress
### ?? mysql
### ?? alertes
### ?? log / cron
Ça va avec les alertes.
### ?? accès sans terminal
Actuellement un NOM_DU_COMPTE dispose d'un accès `ssh` au serveur de sauvegardes.

View File

@ -0,0 +1,87 @@
---
pagename: Informatique en couche
title: L'informatique
subtitle: Une histoire de couche
date: 2019-10-10
author: tierce
modified: 2021-08-22
---
Parce que la [technologie](https://fr.wikipedia.org/wiki/Technologie) est aussi un outil qui renforce les positions [dominantes (au sens social)](https://fr.wikipedia.org/wiki/Domination), il nous semble crucial de proposer un espace d'émancipation numérique (ou digitale).
Découvrir le rapport que nous entretenons avec le [numérique](https://fr.wikipedia.org/wiki/Num%C3%A9rique) peut se faire en prenant conscience des différentes « couches » dont nous nous rendons, volontairement ou non, dépendant·e·s.
## Le langage
Tous [les logiciels](#les logiciels) sont écrits dans un ou plusieurs [langages de programmation](https://fr.wikipedia.org/wiki/Langage_de_programmation) dont la liste est vaste et dont les finalités sont diverses *(facilité d'apprentissage, performance, orientation d'usage, lisibilité du code, portabilité, niveau d'abstraction, etc)*. Ce qui est écrit est ce qu'on appelle le [code source](#le code source).
## Le code source
C'est en quelque sorte le secret de fabrication et de fonctionnement d'un logiciel. Cette « recette de cuisine » est, par défaut, la propriété de l'auteur ou de l'éditeur et vous n'avez ni le [droit d'y avoir accès](https://fr.wikipedia.org/wiki/Droit_d%27acc%C3%A8s_(informatique)), ni le droit de le modifier, ni le droit d'en faire une ingénierie inverse *([rétro-ingénierie](https://fr.wikipedia.org/wiki/R%C3%A9tro-ing%C3%A9nierie#L%C3%A9galit%C3%A9_de_la_r%C3%A9tro-ing%C3%A9nierie_informatique))*. Il va de soi que vous n'avez pas non plus le droit d'en faire des copies.
Ce [code source](https://fr.wikipedia.org/wiki/Code_source) sera soit interprété, soit compilé.
### Logiciel interprété
Avec un logiciel interprété, le [code source](https://fr.wikipedia.org/wiki/Code_source) vous sera fournis puisque c'est la « matière première » qui passera « à la moulinette » d'un [interpréteur](https://fr.wikipedia.org/wiki/Interpr%C3%A8te_(informatique)). Vous aurez au moins la possibilité de lire le [code source](https://fr.wikipedia.org/wiki/Code_source) ou de le faire lire à des personnes disposant des compétences nécessaires, mais ce n'est pas pour autant que vous aurez d'autres droits comme celui de le copier, de le modifier, de le revendre ou de le donner à d'autres sans vous mettre en infraction vis à vis de la [propriété intellectuelle](https://fr.wikipedia.org/wiki/Propri%C3%A9t%C3%A9_intellectuelle).
Quand à [l'interpréteur](https://fr.wikipedia.org/wiki/Interpr%C3%A8te_(informatique)), il vous sera fournis sous la forme d'un logiciel compilé.
### Logiciel compilé
Les logiciels compilés sont eux aussi écrits dans [un langage](#le langage) et leur [code source](#le code source) sera passé à la moulinette d'un [compilateur](https://fr.wikipedia.org/wiki/Compilateur) pour enfin vous être fournis sous la forme de [code objet](https://fr.wikipedia.org/wiki/Code_objet) *(ou fichier binaire dans le jargon numérique)* qui sera compréhensible par [les systèmes dexploitations](#les systèmes d'exploitation) pour lesquels ils ont été… compilés.
Pour espérer découvrir et comprendre l'ensemble des fonctionnalités proposées par un *binaire*, il faudrait qu'il vous soit fourni **accompagné d'une copie de son [code source](https://fr.wikipedia.org/wiki/Code_source)** mais aussi avec celui du compilateur utilisé pour le « fabriquer ».
Sans la mise à disposition de ces [codes sources](https://fr.wikipedia.org/wiki/Code_source), seuls la [rétro-ingénierie](https://fr.wikipedia.org/wiki/R%C3%A9tro-ing%C3%A9nierie) permettrait de s'approcher de ce que *ferait vraiment* un logiciel compilé *(binaire)*. Ces pratiques étant souvent volontairement rendues incompatibles avec les licences privatrices qui accompagnent des binaires propriétaires *(ou [logiciels privateurs](https://www.gnu.org/proprietary/proprietary.fr.html))*, elles sont donc juridiquement considérées comme étant illicites.
Logiciel compilé ne veut pas dire *logiciel privateur* parce que beaucoup de logiciels sont compilés. Mais seuls les logiciels libres seront fournis **avec le code source** et une **licence qui autorise** l'étude, la modification et le partage dans les même conditions en plus du **droit que vous avez** d'utiliser ces logiciels.
## Les licences
Nos sociétés s'articulent autour de la [propriété intellectuelle](https://fr.wikipedia.org/wiki/Propri%C3%A9t%C3%A9_intellectuelle) *(copyright)*, des [licences de logiciels](https://fr.wikipedia.org/wiki/Licence_de_logiciel) et autres [Conditions Générales d'Utilisation](https://fr.wikipedia.org/wiki/Conditions_g%C3%A9n%C3%A9rales_d%27utilisation) pour ce qui sera [des services](#les services).
Chaque bout de code informatique qui compose [les logiciels](#les logiciels), [les systèmes d'exploitation](#les systèmes d'exploitation), [les applications](#les applications) mais aussi [les micrologiciels](#les micrologiciels) sont conditionnés par la législation qui encadre ces outils.
Avec les [licences propriétaires](https://fr.wikipedia.org/wiki/Logiciel_propri%C3%A9taire), et privatrices vous disposez d'un droit d'utilisation **restreint et limité** en déléguant votre confiance aux éditeurs de ces logiciels.
La plus grande différence avec [les licences libres](https://fr.wikipedia.org/wiki/Logiciel_libre) *(copyleft)* tiendra du fait que la licence vous donne tous les droits « à vos risques et périls ». Ce sont des licences qui vous responsabilisent au lieu de vous infantiliser. La seule « obligation » tenant au fait que si vous êtes capable de modifier le fonctionnement d'un [logiciel](#les logiciels) *(au travers de son [code source](https://fr.wikipedia.org/wiki/Code_source))*, vous êtes **tenus de partager avec le reste de la planète** le résultat de votre travail sous ces mêmes conditions.
C'est en comprenant la position dominante que soctroient les entreprises privées se reposant sur la « propriété intellectuelle » et le secret industriel, que la licence [GNU GPL](https://fr.wikipedia.org/wiki/Licence_publique_générale_GNU) fut publiée par [Richard Stallman](https://fr.wikipedia.org/wiki/Richard_Stallman) en 1989 et portée par la [Free Software Fondation](https://fr.wikipedia.org/wiki/Free_Software_Foundation) depuis.
Tout logiciel qui n'est pas compatible avec cette licence est un [logiciel privateur](https://fr.wikipedia.org/wiki/Logiciel_propri%C3%A9taire).
## Les logiciels
Tous les logiciels sont décrits au travers de leur [code source](#le code source) lui même écrit dans un [langage](#Le langage) et accompagné de [licences](#Les licences) qui définissent les droits que les auteurs et les distributeur nous accordent.
### Les systèmes d'exploitation
L'utilisation *(exploitation)* d'un ordinateur, d'un ordiphone, d'un satellite ou d'une voiture par un être humain ou une autre machine, est rendue possible grâce à un logiciel important, sorte de « super logiciel qui permettra l'installation d'autre logiciels applicatifs », c'est le [système d'exploitation](https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%27exploitation).
Ce logiciel a pour particularité de « faciliter » les interactions *(entrées /sorties dans le jargon numérique)* produites par les utilisateurs et utilisatrices ou à leur attention.
Il est important de noter que dans tout système dexploitation, la notion de « droit d'accès » est très présente et fondamentale pour distinguer les êtres humains ou les machines qui disposeraient du « droit d'administration » de celles et ceux qui n'en auraient pas le droit; les utilisateurs et utilisatrices.
Si vous n'êtes pas administrateur ou administratrice des ordinateurs que vous utilisez, quels qu'ils soient, c'est que d'autres personnes le sont à votre place.
### Les applications
Beaucoup plus « spécialisées » que les systèmes d'exploitation, les logiciels applicatifs, sont construits pour répondre à toutes les tâches particulières que les êtres humains seraient susceptibles de réaliser. L'écriture, le dessin, la musique, le dessin architectural, la comptabilité, la communication, l'administration d'autres systèmes numériques, le jeux, la mise à disposition de services en tout genre, le traitement d'image, le pilotage de drone, la cartographies, etc. seront autant de « domaines » pour lesquels il existe un éventail plus ou moins étendu d'applications.
### Les services
Les services sont des logiciels applicatifs destinés à être utilisé par plusieurs utilisateurs ou utilisatrices, humains ou logiciels, simultanément. Ces logiciels très nombreux sont installés sur des [serveurs](https://fr.wikipedia.org/wiki/Serveur_informatique) qui ne sont que des ordinateurs plus performants entassés, la plus part du temps dans des [centres de données](https://fr.wikipedia.org/wiki/Centre_de_donn%C3%A9es) et qui constituent ce qu'on appelle communément [le cloud](https://fr.wikipedia.org/wiki/Cloud_computing).
## Le matériel
Construire et utiliser les logiciels se fait par l'intermédiaire du [matériel informatique](https://fr.wikipedia.org/wiki/Mat%C3%A9riel_informatique).
### Les micrologiciels
Les micrologiciels sont, eux aussi [des logiciels](#les logiciels) qui sont inscrits dans les microcircuits du matériel, que ce soit, par exemple, une imprimante, un ordiphone, un ordinateur, une voiture, une télévision, un frigo ou une carte d'identité électronique.
Ces [firmwares](https://fr.wikipedia.org/wiki/Firmware) sont associables aux différents « périphériques » même si la miniaturisation fait qu'ils sont de plus en plus solidarisé des [cartes mères](https://fr.wikipedia.org/wiki/Carte_m%C3%A8re). Sur ces dernières, ce sont les [bios](https://fr.wikipedia.org/wiki/BIOS_(informatique)) et autres [uefi](https://fr.wikipedia.org/wiki/UEFI) qui s'animeront dés que les vannes du courant électrique s'ouvriront.
## Le réseau
Mettre en branle un nombre incalculable de [neurones humains](https://fr.wikipedia.org/wiki/Neurone) ou [artificiels](https://fr.wikipedia.org/wiki/R%C3%A9seau_de_neurones_artificiels) n'aurait pas beaucoup d'utilité *(pour peu que l'on conçoive l'idée que toutes ces technologies reflètent une quelconque « utilité »)* sans une notion fondamentale et trop souvent méconnue; [le réseau](https://fr.wikipedia.org/wiki/R%C3%A9seau_informatique).

960
content/blog/ldap.md Normal file
View File

@ -0,0 +1,960 @@
---
pagename: LDAP avec SSL
title: LDAP avec le support de SSL
subtitle: Un serveur LDAP pour gérer les comptes utilisateur·ice·s
date: 2021-03-24
author: tierce
---
* Utilisation de [Setup OpenLDAP Server with SSL/TLS on Debian 10](https://kifarunix.com/setup-openldap-server-with-ssl-tls-on-debian-10/)
* Utilisation de [Setting up an OpenLDAP Server with SSL + NFS for User Home Directories on CentOS 7](https://www.lisenet.com/2016/openldap-with-ssl-and-nfs-for-user-home-directories-on-centos-7/)
Ce guide vous expliquera comment configurer le serveur OpenLDAP avec SSL/TLS sur Debian 10 Buster. Les clients et serveurs [OpenLDAP](https://www.openldap.org/doc/admin24/intro.html) sont capables d'utiliser le cadre de sécurité de la couche transport (TLS) pour fournir des protections d'intégrité et de confidentialité et pour prendre en charge l'authentification LDAP en utilisant le mécanisme SASL EXTERNAL.
## Installer OpenLDAP Server avec SSL/TLS sur Debian 10
Mettre à jours le système à jour.
```
# apt update && apt -y upgrade
```
Installer les paquets LDAP
```
# apt -y install slapd ldap-utils ldapscripts
```
Durant l'installation, vous serez invitez à définir le **mot de passe administrateur·ice de LDAP**.
## Afficher les paramètre de la base de données LDAP
Lors de l'installation, la base de données LDAP est automatiquement configurée sur base du nom de domaine distinctif (DN), le nom de l'organisation étant défini sur la base du nom d'hôte du système par défaut. Pour afficher les paramètres de la base de données SLAPD, vous pouvez utiliser la commande ```slapcat```.
```
# slapcat
dn: dc=nodomain
objectClass: top
objectClass: dcObject
objectClass: organization
o: nodomain
dc: nodomain
structuralObjectClass: organization
entryUUID: ff8c93b2-8f04-103a-8b71-4d0da1e98502
creatorsName: cn=admin,dc=nodomain
createTimestamp: 20200919204655Z
entryCSN: 20200919204655.426161Z#000000#000#000000
modifiersName: cn=admin,dc=nodomain
modifyTimestamp: 20200919204655Z
dn: cn=admin,dc=nodomain
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator
userPassword:: e1NTSEF9TXdINjVrRkFwcEs4NjhQY3NaK0dnQmVFZm16UUdoK3c=
structuralObjectClass: organizationalRole
entryUUID: ff8d539c-8f04-103a-8b72-4d0da1e98502
creatorsName: cn=admin,dc=nodomain
createTimestamp: 20200919204655Z
entryCSN: 20200919204655.431118Z#000000#000#000000
modifiersName: cn=admin,dc=nodomain
modifyTimestamp: 20200919204655Z
```
Sur base de la configuration SLADP affichée ci-dessus,
* Le DN de base est définis à ```dn: dc=nodomain```
* L'organigation est définis à ```o: nodomain```
* L'administrateur·ice est définis à ```dn: cn=admin,dc=nodomain```
## Modifier le BaseDN par défaut de OpenLDAP
Si vous avez toutefois besoin du DN de base OpenLDAP par défaut, vous devez reconfigurer le paquet slapd comme indiqué ci-dessous et suivre les instructions.
```
# dpkg-reconfigure slapd
```
Lorsque la commande s'exécute, vous êtes invité à indiquer si vous souhaitez omettre la configuration du serveur OpenLDAP. Sélectionnez **Non** pour que la configuration soit créée pour vous.
Ensuite, configurez le nom de domaine pleinement qualifié (FQDN) de votre serveur OpenLDAP qui sera utilisé pour créer votre DN de base.
> Par exemple ldap.domaine.xyz
Définissez ensuite le nom de votre organisation, le nom de domaine faisant l'affaire.
> Par exemple domaine.xyz
Et choisissez un nouveau mot de passe pour l'administrateur·ice *(cela peut-être le même que choisi précédemment)*
Selectionnnez ensuite le *backend* de la base de données OpenLDAP. **MDB** étant recommandé, selectionnez le est continuez.
Il vous sera demandé si vous souhaitez supprimer la base de données lors de la « purge » du pacquet, rpondez **oui**.
Et ensuite il vous sera demandé si vous souhaitez déplacer « l'ancienne » base de données, répondez également **oui**. L'ancienne base de données sera déplacée dans ```/var/backups```.
Pour vérifer la nouvelle configuration, exécutez simplement ```slapcat```.
```
# slapcat
dn: dc=buster,dc=caldarium,dc=be
objectClass: top
objectClass: dcObject
objectClass: organization
o: caldarium.be
dc: buster
structuralObjectClass: organization
entryUUID: 31a906a8-8f07-103a-9631-e7451d28f069
creatorsName: cn=admin,dc=buster,dc=caldarium,dc=be
createTimestamp: 20200919210238Z
entryCSN: 20200919210238.492144Z#000000#000#000000
modifiersName: cn=admin,dc=buster,dc=caldarium,dc=be
modifyTimestamp: 20200919210238Z
dn: cn=admin,dc=buster,dc=caldarium,dc=be
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator
userPassword:: e1NTSEF9c0tQM3RQQTBCZWlKWmMyZGZDZGFXNTdwVG1ZdFVnRUE=
structuralObjectClass: organizationalRole
entryUUID: 31aa2e52-8f07-103a-9632-e7451d28f069
creatorsName: cn=admin,dc=buster,dc=caldarium,dc=be
createTimestamp: 20200919210238Z
entryCSN: 20200919210238.499757Z#000000#000#000000
modifiersName: cn=admin,dc=buster,dc=caldarium,dc=be
modifyTimestamp: 20200919210238Z
```
Vous pouvez également vérifier le DN de base en utilisant ```ldapsearch``` comme ci-dessous;
```
# ldapsearch -H ldapi:/// -x -LLL -s base -b "" namingContexts
```
Qui devrait vous sortir quelque chose comme ceci;
```
dn:
namingContexts: dc=buster,dc=caldarium,dc=be
```
Et pour afficher le DN racine *(Root DN)*, exécutez la commande suivante;
```
# ldapsearch -H ldapi:/// -Y EXTERNAL -b "cn=config" "(olcRootDN=*)"
```
Ce qui devrait afficher quelque chose comme ceci;
```
dn: dc=buster,dc=caldarium,dc=be
objectClass: top
objectClass: dcObject
objectClass: organization
o: caldarium.be
dc: buster
structuralObjectClass: organization
entryUUID: 31a906a8-8f07-103a-9631-e7451d28f069
creatorsName: cn=admin,dc=buster,dc=caldarium,dc=be
createTimestamp: 20200919210238Z
entryCSN: 20200919210238.492144Z#000000#000#000000
modifiersName: cn=admin,dc=buster,dc=caldarium,dc=be
modifyTimestamp: 20200919210238Z
dn: cn=admin,dc=buster,dc=caldarium,dc=be
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator
userPassword:: e1NTSEF9c0tQM3RQQTBCZWlKWmMyZGZDZGFXNTdwVG1ZdFVnRUE=
structuralObjectClass: organizationalRole
entryUUID: 31aa2e52-8f07-103a-9632-e7451d28f069
creatorsName: cn=admin,dc=buster,dc=caldarium,dc=be
createTimestamp: 20200919210238Z
entryCSN: 20200919210238.499757Z#000000#000#000000
modifiersName: cn=admin,dc=buster,dc=caldarium,dc=be
modifyTimestamp: 20200919210238Z
```
Et pour tester si la connection au serveur LDAP fonctionne, utilisez ```ldapwhoami``` comme ci-dessous;
```
# ldapwhoami -H ldapi:/// -x
```
Ce qui devrait afficher ```anonymous``` si le serveur LDAP fonctionne bien sans authentification.
```
anonymous
```
Pour rechercher tout les [DNs](https://fr.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Search_et_Compare) *(le DN (Distinguished Name) de l'entrée à partir de laquelle effectuer une recherche)* qui descendend du DN de base;
```
# ldapsearch -H ldapi:/// -x -LLL -b dc=buster,dc=caldarium,dc=be dn
```
Devrait afficher ceci;
```
dn: dc=buster,dc=caldarium,dc=be
dn: cn=admin,dc=buster,dc=caldarium,dc=be
```
## Créer un DN de base pour les Utilisateur·ice·s et les Groupes
À partir de la configuration de la base de données SLAPD ci-dessus, le DN de base pour l'administrateur·ice OpenLDAP a été créé. Cependant, comme nous allons gérer d'autres utilisateur·ice·s en dehors de l'administrateur·ice LDAP, il nous faut créer un DN de base pour les utilisateur·ice·s et les groupes.
Créez donc un fichier de format d'échange LDAP *(ldif)* avec le contenu suivant et utilisez-le pour créer le DN de base des utilisateur·ice·s/groupes. Veillez à remplacer le nom de domaine pour correspondre à vos besoins.
```
# cd /root
# mkdir ldap # pour se créer un dossier de travail
# cd ldap
# vi user_group_base.ldif
```
Pour y écrire les informations suivantes, en remplaçant en fonction de vos besoins;
```
dn: ou=people,dc=buster,dc=caldarium,dc=be
objectClass: organizationalUnit
ou: people
dn: ou=group,dc=buster,dc=caldarium,dc=be
objectClass: organizationalUnit
ou: group
```
## Ajouter les DN de base user et group dans la base de données SLAPD
Avec le fichier ```user_group_base.ldif``` vous allez pouvoir remplir la base de données SLADP en utilisant la commande ```ldapadd``` en remplaçant les ```cn``` et ```dc``` en fonction de votre configuration;
```
# ldapadd -x -D cn=admin,dc=buster,dc=caldarium,dc=be -W -f user_group_base.ldif
```
Vous serrez inviter à taper le mot de passe de l'administrateur·ice *(admin)* que vous avez défini lors de la reconfiguration de votre serveur ldap.
Vous derviez avoir ce genre de sortie à l'écran;
```
Enter LDAP Password:
adding new entry "ou=people,dc=buster,dc=caldarium,dc=be"
adding new entry "ou=group,dc=buster,dc=caldarium,dc=be"
```
## Créer des comptes utilisateur·ice·s LDAP
Pour ajouter des comptes utilisateur·ice·s au server LDAP, il faut créer un fichier *ldif* qui contient la définition des attributs des utilisateur·ice·s.
Pour ajouter un·e utilisateur·ice avec un mote de passe, il faut générer le *hachage* de ce mot de passe à l'aide de la commande ```slappasswd```.
```
# slappasswd
New password: TAPER_UN_MOT_DE_PASSE
Re-enter new password: RETAPER_LE_MÊME_MOT_DE_PASSE
{SSHA}9H/LYt91G2lRZuS6Hsml6ZYt5NFcNW6O
```
Il est possible de créer le mot de passe d'un·e utilisateur·ice à l'aide de la même commande ```ldappasswd``` après avoir créer le compte. Voir la section ci-dessous à propose de *Réinitialiser un mot de passe utilisateur·ice*.
Revenons en à créer un fichier *ldif* pour définir le compte d'un·e utilisateur·ice.
```
# vi nouveau_compte.ldif
```
Et ajouter au fichier des informations comme ci-dessous en tenant compte de vos besoins. Vous pourrez utiliser le *hachage* du mot de passe généré ci-dessus pour le coller dans le fichier.
```
dn: uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: bernadette
cn: bernadette
givenName: Bernadette
sn: Lasouris
userPassword: {SSHA}9H/LYt91G2lRZuS6Hsml6ZYt5NFcNW6O
loginShell: /bin/bash
uidNumber: 10000
gidNumber: 10000
homeDirectory: /home/bernadette
shadowMax: 60
shadowMin: 1
shadowWarning: 7
shadowInactive: 7
shadowLastChange: 0
dn: cn=bernadette,ou=group,dc=buster,dc=caldarium,dc=be
objectClass: posixGroup
cn: bernadette
gidNumber: 10000
memberUid: bernadette
```
Vous noterez qu'il y a la définition de l'utilisateur·ice **et** celle de son groupe.
## Ajouter des utilisateur·ice·s à la base de données SLAPD
Une fois que vous avez complété le fichier *ldif* qui définit un·e utilisateur·ice, vous serrez en mesure de l'ajouter avec la commande ```ldapadd``` et votre compte administrateur·ice.
```
# ldapadd -x -D cn=admin,dc=buster,dc=caldarium,dc=be -W -f nouveau_compte.ldif
```
Il vous sera demandé de taper le mot de passe de l'administrateur·ice. Et si votre fichier *ldif* ne contient pas d'erreur, les messages suivants devraient s'afficher.
```
Enter LDAP Password:
adding new entry "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be"
adding new entry "cn=bernadette,ou=group,dc=buster,dc=caldarium,dc=be"
```
En cas d'erreur, vérifiez le contenu de votre fichier *ldif*.
## Lister des utilisateur·ice·s
Vous pourrez utiliser la commande ```ldapsearch``` pour voir défiler la liste des comptes utilisateur·ice·s sous un DN de base.
```
# ldapsearch -x -LLL -b "dc=buster,dc=caldarium,dc=be"
```
## Lister des groupes
La même commande avec un autre DN de base vous listera les groupes.
```
# ldapsearch -x -LLL -b "ou=group,dc=buster,dc=caldarium,dc=be"
```
## Lister des attributs particuliers depuis les ```objectClass```
Pour obtenir une partie des informations relative à un·e utilisateur·ice, par exemple son prénom *(givenName)*, son nom de famille *(sn)*, son identifiant *(uid)* et son répertoire personnel *(homeDirectory)*, vous pourrez construire une requête comme celle ci-dessous.
```
# ldapsearch -x -LLL -b "ou=people,dc=buster,dc=caldarium,dc=be" '(objectclass=*)' uid givenName sn homeDirectory
```
Et elle devrait vous afficher quelque chose comme ceci;
```
dn: ou=people,dc=buster,dc=caldarium,dc=be
dn: uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be
uid: bernadette
givenName: Bernadette
sn: Lasouris
homeDirectory: /home/bernadette
```
Que vous pouvez évidemment filtrer avec la commande *grep* comme ceci par exemple.
```
# ldapsearch -x -LLL -b "ou=people,dc=buster,dc=caldarium,dc=be" '(objectclass=*)' uid givenName sn homeDirectory | grep uid:
```
Ce qui devrait vous afficher uniquement la ligne suivante;
```
uid: bernadette
```
## Supprimer des utilisateur·ice·s et des groupes
C'est la commande ```ldapdelete``` qu'il vous faudra utiliser. Par exemple pour supprimer l'utilisatrice **bernadette** créée ci-dessus. Il vous faudra, bien évidemment, adapter la commande en fonction de la configuration de votre instance LDAP.
```
# ldapdelete -x -W -D "cn=admin,dc=buster,dc=caldarium,dc=be" "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be"
```
Et il en va de même pour le groupe qui lui était associé.
```
# ldapdelete -x -W -D "cn=admin,dc=buster,dc=caldarium,dc=be" "cn=bernadette,ou=group,dc=buster,dc=caldarium,dc=be"
```
Dans les deux cas, vous devrez taper le mot de passe administrateur·ice de votre serveur LDAP.
## Ajouter à nouveau l'utilisateur·ice
Parce qu'on vient de supprimer son compte, il faut le recréer si on veut changer son mot de passe.
Pour se faire, il suffit de relancer la commande utilisée plus haut dans le tutoriel.
```
# ldapadd -x -D cn=admin,dc=buster,dc=caldarium,dc=be -W -f nouveau_compte.ldif
```
## Réinitialiser le mot de passe d'un·e utilisateur·ice
En fonction que vous soyez un·e administarteur·ice ou un·e utilisateur·ice, les commandes et les ordinateurs desquels vous les exécuterez, seront différentes.
### Depuis le serveur, en tant qu'administrateur·ice
Si vous avez besoin de réinitialiser le mot de passe d'un·e utilisateur·ice, vous pouvez utiliser la commande ```ldappasswd```. Par exemple, pour le mot de passe de **bernadette** que nous venons de recréer dans le serveur LDAP et il vous faudra, comme pour les commandes utilisées avant, les adapter selon votre configuration;
```
ldappasswd -H ldapi:/// -x -D "cn=admin,dc=buster,dc=caldarium,dc=be" -W -S "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be"
```
Attention qu'il vous sera demandé **d'abord** le nouveau mot de passe et sa confirmation, **avant** celui de votre compte administarteur·ice.
```
New password:
Re-enter new password:
Enter LDAP Password:
```
### Depuis un ordinateur, également en tant qu'administrateur·ice
Pour ce faire, c'est la même commande ```ldappasswd``` qui pourra être utilisée sur un ordinateur client, à condition que le packet ```ldap-utils``` soit installé.
Il faudra simplement définir l'adresse du serveur LDAP avec le paramètre suivant ```-H ldap://<ldap-server-IP>``` et son nom *(si une résolution de nom à été mise en place sur votre réseau)* ou son adresse IP.
```
ldappasswd -H ldap://buster -x -D "cn=admin,dc=buster,dc=caldarium,dc=be" -W -S "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be"
```
Il vous sera également demandé **d'abord** le nouveau mot de passe et sa confirmation, **avant** celui du compte administarteur·ice.
```
New password:
Re-enter new password:
Enter LDAP Password:
```
## Vérifier si le mot de passe d'un·e utilisateur·ice fonctionne
Comme pour modifier un mot de passe, il est possible de le faire depuis le serveur ou depuis un ordinateur client.
### Depuis le serveur
Et pour tester si le nouveau mot de passe fonctionne, vous pourrez utiliser la commande suivante;
```
# ldapwhoami -vvv -h localhost -D "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be" -x -W
```
Qui vous demandera de taper le mot de pass que vous venez de changer avant de vous afficher le résultat;
```
ldap_initialize( ldap://localhost )
Enter LDAP Password:
dn:uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be
Result: Success (0)
```
Si le mot de passe n'est pas le bon, le résultat sera de ce genre;
```
ldap_bind: Invalid credentials (49)
```
## Depuis un ordinateur client
Même principe que pour le changement de mot de passe, si ce n'est qu'il n'est pas nécessaire de connaître le mot de passe de l'administarteur·ice pour tester la connexion. Pas besoin non plus de le faire depuis une session *root*, puisqu'un·e utilisateur·ice peut tester la connexion à un serveur LDAP sans avoir besoin de droits « élevés ».
Il faudra également définir l'adresse du serveur LDAP avec le paramètre suivant ```-h ldap://<ldap-server-IP>``` et son nom *(si une résolution de nom à été mise en place sur votre réseau)* ou son adresse IP.
```
$ ldapwhoami -vvv -h buster -D "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be" -x -W
```
Il vous sera également demandé de taper le mot de pass que vous venez de changer avant de vous afficher le résultat;
```
ldap_initialize( ldap://localhost )
Enter LDAP Password:
dn:uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be
Result: Success (0)
```
Si le mot de passe n'est pas le bon, le résultat sera de ce genre;
```
ldap_bind: Invalid credentials (49)
```
## Configurer OpenLDAP avec SSL/TLS
## Générer des certificats SSL/TLS
Dans ce guide nous allons utiliser des certificats auto-signés. Il est possible d'utiliser des certificats commerciaux issus d'Aucorités Certificatives ou des certificats issus de Let's Encrypt.
Pour configurer un serveur OpenLDAP avec des certificats SSL/TLS, il faut trois fichiers; un ```certificat CA``` *(CA certificate)*, un ```certificat``` pour le serveur *(server certificate)*, et une ```clé de certificat serveur``` *(server certificate key)*.
Créer un ensemble de dossiers pour stocker les certificats.
```
# mkdir -p /etc/ssl/openldap/{private,certs,newcerts}
```
Lorsque ces dossiers sont créés, il faut renseigner le dossier principal pour stocker les certificats SSL/TLS et les clés dans la section ```[ CA_default ]``` du fichier ```/usr/lib/ssl/openssl.cnf```.
```
vi /usr/lib/ssl/openssl.cnf
```
La partie concernée de ce fichier devrait ressembler à ça;
```
...
[ CA_default ]
#dir = ./demoCA # Where everything is kept
dir = /etc/ssl/openldap
certs = $dir/certs # Where the issued certs are kept
crl_dir = $dir/crl # Where the issued crl are kept
database = $dir/index.txt # database index file.
...
```
Il faudra également quelques autres fichiers pour assurer le suivi des certificats signés.
```
# echo "1001" > /etc/ssl/openldap/serial
# touch /etc/ssl/openldap/index.txt
```
### CA Key (clé de l'autorité certificative)
Créer le fichier de la clé de l'autorité certificative *(CA Key)* à l'aide de la commande ci-dessous et lui renseigner une phrase de passe *(passphrase)*.
```
# openssl genrsa -aes256 -out /etc/ssl/openldap/private/cakey.pem 2048
```
Pour **enlever la phrase de passe**, notamment pour éviter de devoir la déverrouiller à chaque fois qu'on en a besoin, voici comment faire;
```
# openssl rsa -in /etc/ssl/openldap/private/cakey.pem -out /etc/ssl/openldap/private/cakey.pem
```
### CA Certificate (certificat de l'autorité certificative)
```
openssl req -new -x509 -days 3650 -key /etc/ssl/openldap/private/cakey.pem -out /etc/ssl/openldap/certs/cacert.pem
```
Lors de la création de ce certificat, vous avez la possibilité de remplir « une sorte de fiche d'identité » pour votre serveur.
Seul le **FQDN** *(Fully Qualified Domain Name)* est important si votre serveur est joignable depuis Internet. Si c'est un serveur qui sera utilisé uniquement sur un réseau local *(LAN)*, il est tout de même recommandé de mettre son nom pour le **FQDN**.
> Vous pouvez définir le FQDN de votre serveur en modifiant le fichier ```/etc/hosts``` pour y modifier la ligne qui commence par ```127.0.1.1 nom_du_serveur``` pour le faire correspondre à vos besoins. Selon les exemples utilisés dans ce totoriel, la ligne ressemblerait à ceci : ```127.0.1.1 buster.caldarium.be buster```. Cf la [page (en anglais) à propos du hostname](https://manpages.debian.org/buster/hostname/hostname.1.en.html) sur le site de Debian.
Voici par exemple les coordonnées renseignée pour le serveur de ce tutoriel.
```
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:BE
State or Province Name (full name) [Some-State]:Bruxelles
Locality Name (eg, city) []:Laeken
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Caldarium Corp
Organizational Unit Name (eg, section) []:Maison Mère
Common Name (e.g. server FQDN or YOUR name) []:buster.caldarium.be
Email Address []:root@caldarium.be
```
### Server Key (clé privée du serveur)
C'est également un fichier qui nécessitera de définir une phrase de passe *(passphrase)*, que nous enlèveront ensuite pour ne pas avoir à la taper chaque fois que nous devrons acéder à cette clé privée.
Générer la clé privée;
```
# openssl genrsa -aes256 -out /etc/ssl/openldap/private/ldapserver-key.key 2048
```
Lui renseigner une phrase de passe;
```
Generating RSA private key, 2048 bit long modulus (2 primes)
..................................................................+++++
................................................+++++
e is 65537 (0x010001)
Enter pass phrase for /etc/ssl/openldap/private/ldapserver-key.key:
Verifying - Enter pass phrase for /etc/ssl/openldap/private/ldapserver-key.key:
```
Et supprimer la phrase de passe;
```
# openssl rsa -in /etc/ssl/openldap/private/ldapserver-key.key -out /etc/ssl/openldap/private/ldapserver-key.key
```
### Générer un fichier de demande de certification (Certificate Sining Request)
Générer la demande de signature de certificat (CSR). Veillez à configurer les mêmes coordonnées que celles que vous avez utilisés pour générer le fichier de certificat CA ci-dessus.
```
# openssl req -new -key /etc/ssl/openldap/private/ldapserver-key.key -out /etc/ssl/openldap/certs/ldapserver-cert.csr
```
Lors de la génération de ce fichier CSR, il vous sera également demandé de définir une phrase de passe, mais contrairement au *CA Certificate* et à la *Server Key*, il est possible de laisser ce champ vide et de ne rien y écrire.
```
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:BE
State or Province Name (full name) [Some-State]:Bruxelles
Locality Name (eg, city) []:Laeken
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Caldarium Corp
Organizational Unit Name (eg, section) []:Maison Mère
Common Name (e.g. server FQDN or YOUR name) []:buster.caldarium.be
Email Address []:root@caldarium.be
Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:
```
### Sever Certificate (Certificat du serveur)
Nous allons maintenant pouvoir générer un certificat pour le serveur LDAP et le signer avec la clé privée faite ci-dessus.
```
# openssl ca -keyfile /etc/ssl/openldap/private/cakey.pem -cert /etc/ssl/openldap/certs/cacert.pem -in /etc/ssl/openldap/certs/ldapserver-cert.csr -out /etc/ssl/openldap/certs/ldapserver-cert.crt
```
Vérifiez une seconde fois la correspondance des coordonées;
```
Check that the request matches the signature
Signature ok
Certificate Details:
Serial Number: 4097 (0x1001)
Validity
Not Before: Sep 26 18:06:16 2020 GMT
Not After : Sep 26 18:06:16 2021 GMT
Subject:
countryName = BE
stateOrProvinceName = Bruxelles
organizationName = Caldarium Corp
organizationalUnitName = Maison M\C3\A8re
commonName = buster.caldarium.be
emailAddress = root@caldarium.be
X509v3 extensions:
X509v3 Basic Constraints:
CA:FALSE
Netscape Comment:
OpenSSL Generated Certificate
X509v3 Subject Key Identifier:
A2:B2:57:9B:D6:DD:36:8F:B4:64:B5:EA:F2:B9:F7:A8:C5:9E:21:92
X509v3 Authority Key Identifier:
keyid:86:10:11:56:B5:E6:CD:D4:50:74:46:CD:EC:C3:E9:6B:00:E9:86:AC
Certificate is to be certified until Sep 26 18:06:16 2021 GMT (365 days)
Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated
```
### Vérifier l'authenticité du serveur LDAP auprès du CA
La commande suivante nous permettra de vérifier que la chaine de certification est valable entre l'autorité de certification que nous avons créé au début et le certificat du serveur LDAP.
```
# openssl verify -CAfile /etc/ssl/openldap/certs/cacert.pem /etc/ssl/openldap/certs/ldapserver-cert.crt
```
Le résultat devrait être le suivant;
```
/etc/ssl/openldap/certs/ldapserver-cert.crt: OK
```
Maintenant nous disposons, enfin, des trois fichiers indispensable pour garantir l'identité de notre serveur; le certificat de l'autorité *(CA Certificate)*, le certificat du serveur *(Server Certificate)* et la clé du serveur *(Server Key)*.
```
/etc/ssl/openldap/certs/cacert.pem
/etc/ssl/openldap/certs/ldapserver-cert.crt
/etc/ssl/openldap/private/ldapserver-key.key
```
### Changer le propriétaire de ces fichiers
Ensuite, il est nécessaire de définir que l'utilisateur système *openldap* soit le propriétaire du dossier et des fichiers que nous avons créé.
```
# chown -R openldap: /etc/ssl/openldap/
```
## Mettre à jour le serveur OpenLDAP avec les nouveaux certificats TLS
Ensuite, vous devez mettre à jour les certificats TLS du serveur OpenLDAP. Créez donc un fichier LDIF pour définir les attributs TLS comme indiqué ci-dessous;
```
# cd /root/ldap
# vim ldap-tls.ldif
```
Et y renseigner les informations relatives aux fichiers que nous avons créés et n'hésitez pas a adapter les chemins et noms de fichiers en fonction de vos besoins.
```
dn: cn=config
changetype: modify
add: olcTLSCACertificateFile
olcTLSCACertificateFile: /etc/ssl/openldap/certs/cacert.pem
-
replace: olcTLSCertificateFile
olcTLSCertificateFile: /etc/ssl/openldap/certs/ldapserver-cert.crt
-
replace: olcTLSCertificateKeyFile
olcTLSCertificateKeyFile: /etc/ssl/openldap/private/ldapserver-key.key
```
Pour appliquer ces modifications dans la base de données LDAP, c'est la commande ```ldapmodify``` qui sera utilisée.
```
# ldapmodify -Y EXTERNAL -H ldapi:/// -f ldap-tls.ldif
```
Et le réssultat devrait correspondre à ceci.
```
SASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
modifying entry "cn=config"
```
Pour vérifier que les fichiers sont bien pris en compte;
```
# slapcat -b "cn=config" | grep -E "olcTLS"
```
Ce qui dervait donner ceci comme résultat;
```
olcTLSCACertificateFile: /etc/ssl/openldap/certs/cacert.pem
olcTLSCertificateFile: /etc/ssl/openldap/certs/ldapserver-cert.crt
olcTLSCertificateKeyFile: /etc/ssl/openldap/private/ldapserver-key.key
```
Testons également la validité de la nouvelle configuration du LDAP avec la commande suivante;
```
# slaptest -u
```
Et le résultat devrait être le suivant;
```
config file testing succeeded
```
Ensuite il faut modifier le fichier ```/etc/ldap/ldap.conf``` pour y renseigner également la localisation du nouveau certifict TLS.
```
# vi /etc/ldap/ldap.conf
```
Et le modifier comme dans l'extrait ci-dessous;
```
...
# TLS certificates (needed for GnuTLS)
#TLS_CACERT /etc/ssl/certs/ca-certificates.crt
TLS_CACERT /etc/ssl/openldap/certs/cacert.pem
```
Et redémarrer le service OpenLDAP;
```
# systemctl restart slapd
```
## Vérifier la connectivité au LDAP
```
# ldapwhoami -H ldap://buster.caldarium.be -x -ZZ
```
Devrait donner ceci si ça fonctionne;
```
anonymous
```
Sinon, il se pourrait qu'une erreur du genre vous soit retournée;
```
ldap_start_tls: Connect error (-11)
additional info: (unknown error code)
```
Dans ce cas, vous pourriez essayer une commande plus verbeuse pour
```
# ldapsearch -d -1 -x -ZZ -b 'dc=caldarium,dc=be' '(objectclass=*)' | grep TLS:
```
Et peut-être que vous trouvez deux lignes du genre;
```
TLS: hostname (buster) does not match common name in certificate (buster.caldarium.be).
TLS: can't connect: (unknown error code).
```
Ce qui signifie que le FQDN définis lors de la génération des certificats ne correspond pas au FQDN de votre serveur *(cf. une note à propos du FQDN)*.
## Désactiver l'accès anonyme au serveur OpenLDAP
Pour désactiver l'accès anonyme et rendre l'authentification obligatoire pour pouvoir accéder au serveur LDAP, il faut, comme d'habitude maintenant, créer un fichier ldif;
```
# cd /root/ldap
# vi disable-anon.ldif
```
Y mettre les infosmations suivantes;
```
dn: cn=config
changetype: modify
add: olcDisallows
olcDisallows: bind_anon
dn: cn=config
changetype: modify
add: olcRequires
olcRequires: authc
dn: olcDatabase={-1}frontend,cn=config
changetype: modify
add: olcRequires
olcRequires: authc
```
Et mettre à jour la base de données slapd;
```
# ldapadd -Y EXTERNAL -H ldapi:/// -f disable-anon.ldif
```
Tester l'accès anonyme, qui ne devrait pas fonctionner comme ci-dessus, mais renvoyer un message d'erreur.
```
# ldapwhoami -H ldapi:/// -x -ZZ
```
Devrait retourner ceci;
```
ldap_bind: Inappropriate authentication (48)
additional info: anonymous bind disallowed
```
## Tester l'accès authentifé
Puisque l'accès anonyme n'est plus possible, voyons si l'accès en tant qu'utilisateur·ice fonctionne bien;
```
# ldapwhoami -H ldapi:/// -x -ZZ -D "uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be" -x -W
```
Taper le mot de passe de l'utilisatrice Bernadette, et si tout se passe bien, vous devriez avoir ce genre de message en sortie;
```
Enter LDAP Password:
dn:uid=bernadette,ou=people,dc=buster,dc=caldarium,dc=be
```
## Configurer la journalisation (Logging)
De manière similaire, à l'aide d'un fichier ldif, nous allons activer la journalisation vers un fichier *log*. Tout d'abord, il faut configurer OpenLDAP pour enregistrer les connexions, les opérations et les statistiques de résultats. Cette journalisation est activée au niveau 256 du journal avec les statistiques par mot-clé. Cela peut être fait en modifiant l'attribut olcLogLevel comme indiqué ci-dessous.
Créons un fichier ldif avec les options nécessaires;
```
# cd /root/ldap
# vi enable-ldap-log.ldif
```
Pour y mettre le contenu suivant;
```
dn: cn=config
changeType: modify
replace: olcLogLevel
olcLogLevel: stats
```
Et mettons ça dans la base de données slapo;
```
ldapmodify -Y external -H ldapi:/// -f enable-ldap-log.ldif
```
Ce qui devrait nous répondre un truc du genre;
```
SASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
modifying entry "cn=config"
```
Vérifions si c'est bien pris en compte dans la DB;
```
ldapsearch -Y EXTERNAL -H ldapi:/// -b cn=config "(objectClass=olcGlobal)" olcLogLevel -LLL
```
Ce qui devrait retourner ceci;
```
SASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
dn: cn=config
olcLogLevel: stats
```
Il faut maintenant configurer ```rsyslog``` pour demander à OpenLDAP d'écrire les journaux dans dans fichier donné. Pour plus d'explications sur le fonctionnement de ```rsyslog```, n'hésitez pas à jeter un coup d'œil sur le [wiki de Archlinux *(anglais)*](https://wiki.archlinux.org/index.php/Rsyslog).
```
# echo "local4.* /var/log/slapd.log" >> /etc/rsyslog.conf
```
Et redémarrons rsyslog et slapd
```
# systemctl restart rsyslog
# systemctl restart slapd
```
Il est maintenant possible de suivre le journal dans ```/var/log/slapd.log```
```
# tail -f /var/log/slapd.log
```
> Utilisez CTRL+C pour arrêter le suivi continu
Voilà ! Jusqu'à présent, nous avons appris comment configurer le serveur OpenLDAP avec SSL/TLS sur Debian 10.
ÇA serait chouette de faire un autre guide sur la configuration des clients LDAP pour l'authentification via le serveur LDAP.

View File

@ -1,10 +0,0 @@
---
Title: Contact
ShortTitle: Contact
Date: 2019-10-10
Modified: 2021-07-04
---
# Contact
help@guragist.es

View File

@ -1,7 +1,7 @@
---
pagename: GNU is Not Unix
title: GNU
subtitle: GNU N'est pas Unix
subtitle: GNU N'est pas Unix !
description: Mais c'est quoi un <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%27exploitation" target="_blank">système d'exploitation</a> ?
date: 2021-07-01
modified: 2021-07-04

View File

@ -13,6 +13,9 @@ TIMEZONE = 'Europe/Brussels'
DEFAULT_LANG = u'fr'
# Je sais pas trop à quoi ça sert
FILENAME_METADATA = '(?P<slug>.*)'
# Les fichiers produits sont mis dans des dossiers
ARTICLE_URL = '/{category}/{slug}.html'
ARTICLE_SAVE_AS = '{category}/{slug}.html'
@ -29,8 +32,8 @@ AUTHOR_FEED_RSS = None
# Liens statiques utilisés dans le menu.
# ('texte affiché','url','icone ForkAwsome')
# Pour les icones ForkAwsome voir https://forkaweso.me/Fork-Awesome/cheatsheet/
MENUITEMS = (('Home', './', 'fa-home'),
('Wiki', 'https://wiki.gnuragist.es', 'fa-book'),
MENUITEMS = (('Home', '/', 'fa-home'),
('Blog', '/category/blog.html', 'fa-book'),
('Git Sources', 'https://git.gnuragist.es/git/wildebeest/website','fa-gitea'),
('Webmail', 'https://mamifere.gnuragist.es','fa-envelope'),
('Pads', 'https://doc.gnuragist.es','fa-file-text'),
@ -40,7 +43,7 @@ MENUITEMS = (('Home', './', 'fa-home'),
SOCIAL = (('You can add links in your config file', '#'),
('Another social link', '#'),)
DEFAULT_PAGINATION = True
DEFAULT_PAGINATION = False
THEME = 'template/gnuragistes'
@ -48,7 +51,7 @@ THEME = 'template/gnuragistes'
#STATIC_EXCLUDES = ['template/gnuragistes/static/css/Fork-Awesome/.github', 'template/gnuragistes/static/css/Fork-Awesome/*']
# Uncomment following line if you want document-relative URLs when developing
#RELATIVE_URLS = True
RELATIVE_URLS = True
DISPLAY_PAGES_ON_MENU = True

View File

@ -1,23 +1,5 @@
/* classes */
.toolbox
{
color:white;
background-color: grey;
position: fixed;
overflow: hidden;
z-index: 2400;
opacity: 0.70;
right: 0px;
top: 0px !important;
-webkit-transition: all 0.5s ease-in-out;
-moz-transition: all 0.5s ease-in-out;
-ms-transition: all 0.5s ease-in-out;
-o-transition: all 0.5s ease-in-out;
transition: all 0.5s ease-in-out;
padding: 2em;
}
.hide
{
visibility: hidden;
@ -55,6 +37,7 @@ a.button
color: lightgreen;
text-align:center;
transition: all 0.2s;
font-size: 1.5rem;
}
a.button > i
@ -75,8 +58,10 @@ a.button:hover > i
color: #0F0F0F;
}
a.selected
{
/* border:0.1em solid lightgreen; */
}
/* pour les blocks de code - très sommaire */
.highlight pre {
background: #272822;
color: #bbb;
padding: 0.5rem;
}

View File

@ -28,19 +28,6 @@ body
/*background: linear-gradient(to left top, #0F0F0F, #000) fixed;*/
}
ul
{
display: flex;
justify-content: space-around;
align-items: center;
min-height: 8vh;
font-weight: bold;
font-size: 2rem;
list-style: none;
padding-left: 1rem;
}
li a,
a
{
text-decoration: none;
@ -50,24 +37,24 @@ a
h1
{
font-size: 4rem;
color: white;
color: #bbb;
}
h2
{
font-size: 3rem;
color: white;
color: #bbb;
}
h3
{
font-size: 2rem;
color: white;
color: #bbb;
}
hr
{
border: 0.3rem solid grey;
border: 0.3rem solid #bbb;
border-radius: 0.5rem;
}
@ -77,11 +64,10 @@ img
height: auto;
}
p
p, li
{
font-size: 2rem;
font-size: 1.5rem;
/*text-transform: uppercase;*/
font-weight: bold;
}
/* for smaller screens transformations */
@ -93,11 +79,6 @@ p
line-height: 1.8;
}
div
{
font-size: 1.6rem;
}
h1
{
font-size: 4rem;
@ -121,9 +102,16 @@ p
p
{
font-size: 2rem;
font-size: 1.5rem;
text-transform: uppercase;
font-weight: bold;
}
}
pre {
line-height: 2.1rem;
font-family: courier;
font-size: 1.5rem;
}

View File

@ -0,0 +1,14 @@
{% extends "base.html" %}
{% block pagename %}{{ article.pagename }}{% endblock %}
{% block title %}{{ article.title }}{% endblock %}
{% block subtitle %}{{ article.subtitle }}{% endblock %}
{% block description %}
{{ article.author }} - {{ article.date|strftime('%d %B %Y') }}
{% if article.modified %}
, modifié le {{ article.modified|strftime('%d %B %Y') }}
{% endif %}
{% endblock %}
{% block date %}{{ article.date | strftime('%a, %d %B %Y') }}{% endblock %}
{% block author %}{{ article.author }}{% endblock %}
{% block content %}{{ article.content }}{% endblock %}

View File

@ -2,48 +2,43 @@
<html lang="fr" dir="ltr">
<head>
<meta charset="utf-8">
<title>{% block pagename %}{%endblock%} | {{SITENAME}}</title>
<meta name="keywords" content="support gnu/linux, bruxelles, logiciels libres, collectif">
<meta name="description" content="Gnuragistes, support GNU/Linux et collectivité" />
<meta name="robots" content="archive,index,follow" />
<link href="./theme/css/gnuragistes.css" rel="stylesheet" type="text/css" />
<link rel="shortcut icon" href="./theme/images/zebras-favicon.png" />
<meta charset="utf-8">
<title>{% block pagename %}{%endblock%} | {{SITENAME}}</title>
<meta name="keywords" content="support gnu/linux, bruxelles, logiciels libres, collectif">
<meta name="description" content="Gnuragistes, support GNU/Linux et collectivité" />
<meta name="robots" content="archive,index,follow" />
<link href="/theme/css/gnuragistes.css" rel="stylesheet" type="text/css" />
<link rel="shortcut icon" href="/theme/images/zebras-favicon.png" />
</head>
<body>
<div id=menu>
<nav id=menu>
{% for text, link, icon in MENUITEMS %}
<a href="{{ link }}" class="button {% if text.lower() == page_name %}selected{% endif %}">
<a href="{{ link }}" class="button">
{% if icon != "none" %}<i class="fa {{icon}}"></i>{% endif %}
{{ text }}</a>
{% endfor %}
{% for menu_page in PAGES|sort(attribute='order')|rejectattr('hiddeninmenu') %}
<a href="/{{ menu_page.url }}" class="button {% if page and page.shorttitle == menu_page.shorttitle %}selected{% endif %}">
{{ menu_page.shorttitle }}</a>
{% endfor %}
</div>
</nav>
<h1>{% block title %}{% endblock %}</h1>
<section id=head>
<h1>{% block title %}{% endblock %}</h1>
<h2>{% block subtitle %}{% endblock %}</h2>
<h2>{% block subtitle %}{% endblock %}</h2>
<hr>
<h3>{% block description%}{% endblock %}</h3>
<div id="main">
<hr>
<h3>{% block description%}{% endblock %}</h3>
</section>
<section id="main">
{% block content %}
{% endblock %}
</div>
</section>
<div id="footer" class="footer">
<footer class