Nextcloud - E03 OpenLDAP - Administration

Hello,

Maintenant que notre OpenLDAP est opérationnel, on va mettre en place plusieurs outils permettant son administration. L’objectif étant de pouvoir réaliser le plus facilement et rapidement possible des opérations de gestion classique d’un LDAP. Cela inclut la création d’utilisateurs, leur modification, le déverouillage d’un utilisateur (lorsque celui-ci à échoué trop de fois à s’authentifier par exemple), où au contraire son verrouillage lorsque celui-ci n’est plus autorisé à se connecter. On peut également avoir des cas de figure qui ne nécessitent pas d’actions, mais simplement un accès en lecture seule à certaines informations.

L’utilisation de ces outils d’administrations est donc restreinte à des utilisateurs privilégiées.

PHPLDAPAdmin

On commence avec PHPLDAPAdmin qui est une interface web permettant de naviguer dans l’arborescence de notre LDAP. C’est une interface d’administration très complète et qui ne sera utilisable que par les administrateurs LDAP.

Pour mettre en place PHPLDAPAdmin on utilisera l’image Docker osixia/phpldapadmin, dont voici le yaml :

- name: phpldapadmin
  image: osixia/phpldapadmin
  restart_policy: unless-stopped
  security_opts:
    - no-new-privileges=true
  command: '--loglevel warning'
  purge_networks: true
  networks_cli_compatible: yes
  networks:
    - name: net-traefik
      aliases:
        - phpldapadmin.mydomain.com
    - name: net-openldap
      aliases:
        - phpldapadmin.mydomain.com
  env:
    PHPLDAPADMIN_LDAP_HOSTS: "#PYTHON2BASH:[{'ldap.mydomain.com': [{'server': [{'tls': True}]}]}]"
    PHPLDAPADMIN_LDAP_CLIENT_TLS_CA_CRT_FILENAME: 'root.ca.cert'
    PHPLDAPADMIN_SERVER_ADMIN: "admin@email"
    PHPLDAPADMIN_HTTPS: "false"
    PHPLDAPADMIN_TRUST_PROXY_SSL: "true"
  volumes:
    - phpldapadmin:/var/www/phpldapadmin
    - phpldapadmin-tls:/container/service/ldap-client/assets/certs
    - /etc/localtime:/etc/localtime:ro
  labels:
    traefik.enable: 'true'
    traefik.docker.network: net-traefik
    traefik.http.routers.phpldapadmin-http.entrypoints: http
    traefik.http.routers.phpldapadmin-http.middlewares: https-redirect
    traefik.http.routers.phpldapadmin-http.rule: Host(`phpldapadmin.mydomain.com`)
    traefik.http.routers.phpldapadmin-https.entrypoints: https
    traefik.http.routers.phpldapadmin-https.rule: Host(`phpldapadmin.mydomain.com`)
    traefik.http.routers.phpldapadmin-https.tls: 'true'
    traefik.http.routers.phpldapadmin-https.tls.options: 'default'
    traefik.http.routers.phpldapadmin-https.middlewares: ipfilter,secure-headers,gzip

Encore une fois, je ne détaillerai pas tous les paramètres “communs”, pour ce cas, uniquement les variables d’environnements :

PHPLDAPADMIN_LDAP_HOSTS: "#PYTHON2BASH:[{'ldap.mydomain.com': [{'server': [{'tls': True}]}]}]"" : Le FQDN du serveur LDAP auquel on veux se connecter, et on spécifie l’utilisation de startTLS.
PHPLDAPADMIN_SERVER_ADMIN: "admin@email" : Va correspondre au paramètre du vhost apache2 ServerAdmin.
PHPLDAPADMIN_HTTPS: "false" : Désactive la génération d’un certificat auto-signé et son utilisation dans le vhost apache2.
PHPLDAPADMIN_TRUST_PROXY_SSL: "true" : Ajoute le paramètre SetEnvIf X-Forwarded-Proto "^https$" HTTPS=on dans la configuration apache2, et ainsi permet l’utilisation d’un reverse-proxy.

Maintenant qu’on à notre PHPLDAPAdmin, on veux pouvoir créer des utilisateurs le plus efficacement possible. Une fois connecté sur l’interface, il est possible de créer des entrées LDAP en se basant sur des “templates”, qui permettent de créer des entrées plus rapidement qu’à partir de zéro (exemple avec Generic: User Account). J’ai eu un peu de mal à comprendre comment fonctionne ce système de templates, j’ai cru initialement qu’ils étaient générés automatiquement en se basant sur des paramètres du serveur LDAP auquel on se connecte. Puis en lisant la F.A.Q. de PHPLDAPAdmin, j’ai compris qu’il s’agit simplement de fichiers xml qu’il nous faut placer dans le docroot de PHPLDAPAdmin, dans le dossier templates/creation et éventuellement dans templates/modification.

J’ai donc créé un fichier xml afin de pouvoir gérer la création des utilisateurs le plus efficacement possible. Si on compare au template standard Generic: User Account, on veut que l’User ID soit généré automatiquement de la forme First Name.Last Name, on veut que Password utilise par défaut une méthode d’encryption beaucoup plus sécurisée (md5 par défaut), que les champs GID Number, Home Directory et Login Shell soient déjà remplis, et on veut disposer de champs supplémentaires : Email, et telephoneNumber par exemple. Voici ce qu’on obtient :

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE template SYSTEM "../template.dtd">

<template>
<askcontainer>1</askcontainer>
<description>New User Account</description>
<icon>ldap-user.png</icon>
<invalid>0</invalid>
<rdn>cn</rdn>
<title>Custom: User Account</title>
<visible>1</visible>

<objectClasses>
<objectClass id="inetOrgPerson"></objectClass>
<objectClass id="posixAccount"></objectClass>
</objectClasses>

<attributes>
<attribute id="givenName">
 <display>First name (givenName)</display>
 <icon>ldap-uid.png</icon>
 <onchange>=autoFill(cn;%givenName% %sn%)</onchange>
 <onchange>=autoFill(uid;%givenName/l%.%sn/l%)</onchange>
 <order>1</order>
 <page>1</page>
</attribute>
<attribute id="sn">
 <display>Last name (sn)</display>
 <onchange>=autoFill(cn;%givenName% %sn%)</onchange>
 <onchange>=autoFill(uid;%givenName/l%.%sn/l%)</onchange>
 <order>2</order>
 <page>1</page>
</attribute>
<attribute id="cn">
 <display>Common Name (cn)</display>
 <order>3</order>
 <page>1</page>
</attribute>
<attribute id="uid">
 <display>User ID (uid)</display>
 <order>4</order>
 <page>1</page>
 <spacer>1</spacer>
</attribute>
<attribute id="userPassword">
 <display>Password (userPassword)</display>
 <helper>
    <display>Encryption</display>
    <id>enc</id>
    <value>=php.PasswordEncryptionTypes()</value>
    <default>sha512crypt</default>
 </helper>
 <icon>lock.png</icon>
 <order>5</order>
 <page>1</page>
 <post>=php.PasswordEncrypt(%enc%;%userPassword%)</post>
 <spacer>1</spacer>
 <verify>1</verify>
</attribute>
<attribute id="mail">
  <display>Email (mail)</display>
  <order>6</order>
  <page>1</page>
</attribute>
<attribute id="telephoneNumber">
  <display>Phone (telephoneNumber)</display>
  <icon>phone.png</icon>
  <order>7</order>
  <page>1</page>
</attribute>
<attribute id="uidNumber">
 <display>UID Number (uidNumber)</display>
 <icon>terminal.png</icon>
 <order>8</order>
 <page>1</page>
 <readonly>1</readonly>
 <value>=php.GetNextNumber(/;uidNumber)</value>
</attribute>
<attribute id="gidNumber">
  <display>GID Number (gidNumber)</display>
  <order>9</order>
  <page>1</page>
  <value>1000</value>
</attribute>
<attribute id="homeDirectory">
 <display>Home directory (homeDirectory)</display>
 <value>/nonexistent</value>
 <order>10</order>
 <page>1</page>
</attribute>
<attribute id="loginShell">
 <display>Login shell (loginShell)</display>
 <order>11</order>
 <page>1</page>
  <default id="/usr/sbin/nologin">No Login</default>
  <type>select</type>
  <value id="/bin/bash">Bash</value>
  <value id="/bin/csh">C Shell</value>
  <value id="/bin/dash">Dash</value>
  <value id="/bin/sh">Shell</value>
  <value id="/bin/tsh">Turbo C Shell</value>
  <value id="/bin/false">False</value>
</attribute>
</attributes>
</template>

On est presque bons. Il ne reste plus qu’à créer nos groupes. Il n’y a pas de template par défaut pour créer des groupes avec l’overlay memberOf, j’ai dû fouiller un peu. Avec PHPLDAPAdmin il faut donc sélectionner default lorsqu’on veut créer une nouvelle entréee, et on choisit soit groupOfNames soit groupOfUniqueNames, j’ai personnellement fait avec la deuxième option. Pour la différence, je vous invite à lire ces deux liens, dont le premier que j’ai déjà mentionné :

Et un mini tuto déniché ailleurs : https://www.thedeveloperfriend.com/ldap/user-security-groups-in-openldap/

On passera cinq minutes pour faire un template pour les groupes et un autre pour les passwordPolicy au cas où.

Outils de LDAP Tool Box

LDAP Tool Box est une compilation of tools for LDAP administrators, to ease their rough life, pour les citer. Je n’ai pas trouvé de mention d’organisme ou d’entreprise qui serait derrière LTB, cela semble être juste le travail de quelques individus passionés.

Self-Service-Password

Self-Service-Password (SSP), est une interface web permettant de réinitialiser son mot de passe LDAP, ainsi que de faire une requête de mot de passe oublié. Outil qu’on met donc à disposition de tous nos utilisateurs.

J’utilisais initalement l’image dtwardow/ldap-self-service-password qui est relativement populaire sur le DockerHub, qui semble être à jour, et dont voici le yaml :

- name: lssp
  image: dtwardow/ldap-self-service-password
  restart_policy: unless-stopped
  security_opts:
    - no-new-privileges=true
  purge_networks: true
  networks_cli_compatible: yes
  networks:
    - name: net-traefik
      aliases:
        - lssp.mydomain.com
    - name: net-openldap
      aliases:
        - lssp.mydomain.com
  env:
    SERVER_HOSTNAME: 'lssp.mydomain.com'
    LSSP_ATTR_LOGIN: 'uid'
    LSSP_ATTR_FN: 'cn'
    LSSP_ATTR_MAIL: 'mail'
    LSSP_DEFAULT_ACTION: 'change'
    LDAP_BASE: 'ou=users,dc=MyDomain'
    LDAP_HOST: 'ldap.mydomain.com'
    LDAP_PORT: '389'
    LDAP_USER: 'cn=manager,dc=MyDomain'
    LDAP_PASS: 'managerPwd'
    LDAP_STARTTLS: 'true'
    SMTP_HOST: 'smtp.mydomain.com"
    SMTP_PORT: '25'
    SMTP_FROM: 'ldap@mydomain.com'
    SMTP_TLS: 'true'
  labels:
    traefik.enable: 'true'
    traefik.docker.network: net-traefik
    traefik.http.routers.ltb-lssp-http.entrypoints: http
    traefik.http.routers.ltb-lssp-http.middlewares: https-redirect
    traefik.http.routers.ltb-lssp-http.rule: Host(`lssp.mydomain.com`)
    traefik.http.routers.ltb-lssp-https.entrypoints: https
    traefik.http.routers.ltb-lssp-https.rule: Host(`lssp.mydomain.com`)
    traefik.http.routers.ltb-lssp-https.tls: 'true'
    traefik.http.routers.ltb-lssp-https.tls.options: 'default'
    traefik.http.routers.ltb-lssp-https.middlewares: ipfilter,secure-headers,gzip

Mais lors de l’écriture de ce même article, je me suis repenché sur la question de Self-Service-Password et l’image dtwardow/ldap-self-service-password, et celle-ci ne me satisfait plus tant que ça. Les possibilités de configuration sont, même si elles sont suffisantes pour un cas standard, limitées dans ce que je souhaite réaliser. En outre, cette image n’est disponible que pour l’architecture amd64, donc pas compatible RaspberryPi, et n’est pas très optimisée.

J’ai construit précédemment deux autres images pour deux autres outils de LTB, et j’ai donc décidé de faire le même travail pour Self-Service-Password, et d’en profiter pour mutualiser mes efforts, et gérer les trois outils sur un même dépôt Git : https://github.com/NoxInmortus/docker-ldap-tool-box

Voici ce qu’on devrait avoir dans notre nouveau yaml :

- name: ltb-ssp
  image: noxinmortus/docker-ldap-tool-box:self-service-password
  restart_policy: unless-stopped
  security_opts:
    - no-new-privileges=true
  purge_networks: true
  networks_cli_compatible: yes
  networks:
    - name: net-traefik
      aliases:
        - lssp.mydomain.com
    - name: net-openldap
      aliases:
        - lssp.mydomain.com
  env:
    APACHE_SERVERADMIN: 'admin@mydomain.com'
    APACHE_SERVERNAME: 'lssp.mydomain.com'
    APACHE_TRUST_PROXY_SSL: 'true'
    APACHE_AUTH_LDAP_TRUSTED_CA: 'CA_BASE64 /usr/local/share/ca-certificates/root.ca.cert'
    LDAP_URL: 'ldap://ldap.mydomain.com'
    LDAP_STARTTLS: 'true'
    LDAP_BINDDN: 'cn=manager,dc=MyDomain'
    LDAP_BINDPW: managerPwd'
    LDAP_BASE: 'ou=users,dc=MyDomain'
    LDAP_USE_TOKENS: 'true'
    LDAP_MAIL_USE_LDAP: 'true'
    LDAP_SMTP_HOST: '172.17.0.1'
    LDAP_SMTP_ALLOW_SELFSIGNED: 'true'
    LDAP_MAIL_FROM: 'ldap@mydomain.com'
    LDAP_MAIL_FROM_NAME: 'ldap@mydomain.com'
    LDAP_SMTP_AUTOTLS: 'true'
    LDAP_MAIL_NOTIFY: 'true'
    LDAP_RECAPTCHA: 'true'
    LDAP_RECAPTCHA_PUBLICKEY: 'myPublicKey'
    LDAP_RECAPTCHA_PRIVATEKEY: 'myPrivateKey'
    LDAP_RECAPTCHA_TYPE: 'checkbox'
    LDAP_PWD_MIN_LENGTH: '8'
    LDAP_PWD_MIN_LOWER: '1'
    LDAP_PWD_MIN_UPPER: '1'
    LDAP_PWD_MIN_DIGIT: '1'
    LDAP_PWD_FORBIDDEN_LDAP_FIELDS: "'cn', 'givenName', 'sn', 'mail', 'uid'"
    LDAP_PWD_SHOW_POLICY: 'always'
  volumes:
    - /etc/localtime:/etc/localtime:ro
    - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro
  labels:
    traefik.enable: 'true'
    traefik.docker.network: net-traefik
    traefik.http.routers.ltb-lssp-http.entrypoints: http
    traefik.http.routers.ltb-lssp-http.middlewares: https-redirect
    traefik.http.routers.ltb-lssp-http.rule: Host(`lssp.mydomain.com`)
    traefik.http.routers.ltb-lssp-https.entrypoints: https
    traefik.http.routers.ltb-lssp-https.rule: Host(`lssp.mydomain.com`)
    traefik.http.routers.ltb-lssp-https.tls: 'true'
    traefik.http.routers.ltb-lssp-https.tls.options: 'default'
    traefik.http.routers.ltb-lssp-https.middlewares: ipfilter,secure-headers,gzip
    traefik.http.services.ltb-lssp-https.loadbalancer.server.port: '8080'

Service Desk

Deuxième application de LTB qu’on va utiliser, Service Desk (SD) : a web application for administrators and support teams. It allows to browse accounts in an LDAP directory, view and update their status.. Une application web qui va permettre aux administrateurs de vérifier/changer des mots de passe utilisateurs, ainsi que de vérouiller ou déverouiller des comptes. L’outil est donc beaucoup moins puissant que PHPLDAPAdmin, mais beaucoup plus ergonomique et efficace pour l’usage qui lui est dédié. On peut donc potentiellement donner accès à cet outil à une équipe support moins privilégiée que des admins.

Voici le yaml qui permet de le déployer :

- name: ltb-service-desk
  image: noxinmortus/docker-ldap-tool-box:service-desk
  restart_policy: unless-stopped
  hostname: sd.mydomain.com
  security_opts:
    - no-new-privileges=true
  purge_networks: true
  networks_cli_compatible: yes
  networks:
    - name: net-traefik
      aliases:
        - sd.mydomain.com
    - name: net-openldap
      aliases:
        - sd.mydomain.com
  env:
    APACHE_SERVERADMIN: 'admin@mydomain.com'
    APACHE_SERVERNAME: 'sd.mydomain.com'
    APACHE_TRUST_PROXY_SSL: 'true'
    APACHE_LDAP_AUTH: 'true'
    APACHE_AUTH_LDAP_URL: 'ldap://ldap.mydomain.com/dc=MyDomain?uid STARTTLS'
    APACHE_AUTH_LDAP_GROUP: 'cn=admins,ou=groups,dc=MyDomain'
    APACHE_AUTH_LDAP_BIND_DN: 'cn=readonly,dc=MyDomain'
    APACHE_AUTH_LDAP_BIND_PWD: 'readonlyPwd'
    APACHE_AUTH_LDAP_TRUSTED_CA: 'CA_BASE64 /usr/local/share/ca-certificates/root.ca.cert'
    LDAP_URL: 'ldap://ldap.mydomain.com'
    LDAP_BINDDN: 'cn=manager,dc=MyDomain'
    LDAP_BINDPW: 'managerPwd'
    LDAP_BASE: 'dc=MyDomain'
    LDAP_STARTTLS: 'true'
    LDAP_DEFAULT_PPOLICY: 'cn=default,ou=ppolicies,dc=MyDomain'
  volumes:
    - /etc/localtime:/etc/localtime:ro
    - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro
  labels:
    traefik.enable: 'true'
    traefik.docker.network: net-traefik
    traefik.http.routers.ltb-sd-http.entrypoints: http
    traefik.http.routers.ltb-sd-http.middlewares: https-redirect
    traefik.http.routers.ltb-sd-http.rule: Host(`sd.mydomain.com`)
    traefik.http.routers.ltb-sd-https.entrypoints: https
    traefik.http.routers.ltb-sd-https.rule: Host(`sd.mydomain.com`)
    traefik.http.routers.ltb-sd-https.tls: 'true'
    traefik.http.routers.ltb-sd-https.tls.options: 'default'
    traefik.http.routers.ltb-sd-https.middlewares: ipfilter,secure-headers,gzip
    traefik.http.services.ltb-sd-https.loadbalancer.server.port: '8080'

On peut voir que dans les variables d’environnement, on a ici renseigné le nécessaire afin d’avoir une authentification en amont, et n’autorisant que les membres du groupe “admins” à accéder à l’outil. On a également la variable LDAP_DEFAULT_PPOLICY qui permet de renseigner la politique de mot de passe par défaut. A l’heure de l’écriture de cet article je n’ai cependant pas l’impression que celle-ci est prise en compte. A confirmer ultérieurement.

White-Pages

White-Pages (WP) est la troisième application de LTB qu’on utilise ici. Pour présenter WP :

White Pages is a PHP application that allows users to search and display data stored in an LDAP directory.

The application can be used on standard LDAPv3 directories and Active Directory, as all searched attributes can be set in configuration.

It has the following features:

Quick search: a simple input in menu bar searching on some classic attributes Advanced search: a full form to search on several attributes Directory : display of all entries in a table form Gallery: display of all entries with their photo Search and display groups and members Export results as CSV Export entry as vCard

C’est une interface web en read-only qui permet d’afficher les informations des utilisateurs, des groupes, mais également de pouvoir réaliser des extracts CSV. C’est le type d’outil qu’un manager, un employé des ressources humaines, un responsable de la communication peut avoir besoin.

En voici donc le yaml :

# https://github.com/ltb-project/white-pages
- name: white-pages
  image: noxinmortus/docker-ldap-tool-box:white-pages
  restart_policy: unless-stopped
  security_opts:
    - no-new-privileges=true
  purge_networks: true
  networks_cli_compatible: yes
  networks:
    - name: net-traefik
      aliases:
        - wp.mydomain.com
    - name: net-openldap
      aliases:
        - wp.mydomain.com
  env:
    APACHE_SERVERADMIN: 'admin@mydomain.com'
    APACHE_SERVERNAME: 'wp.mydomain.com'
    APACHE_TRUST_PROXY_SSL: 'true'
    APACHE_LDAP_AUTH: 'true'
    APACHE_AUTH_LDAP_URL: 'ldap://ldap.mydomain.com/dc=MyDomain?uid STARTTLS'
    APACHE_AUTH_LDAP_GROUP: 'cn=managers,ou=groups,dc=MyDomain'
    APACHE_AUTH_LDAP_BIND_DN: 'cn=readonly,dc=MyDomain'
    APACHE_AUTH_LDAP_BIND_PWD: 'readonlyPwd'
    APACHE_AUTH_LDAP_TRUSTED_CA: 'CA_BASE64 /usr/local/share/ca-certificates/root.ca.cert'
    LDAP_URL: 'ldap://ldap.mydomain.com'
    LDAP_BINDDN: 'cn=readonly,dc=MyDomain'
    LDAP_BINDPW: 'readonlyPwd'
    LDAP_BASE: 'dc=MyDomain'
    LDAP_STARTTLS: 'true'
    LDAP_EDIT_LINK: 'https://phpldapadmin.mydomain.com'
  volumes:
    - /etc/localtime:/etc/localtime:ro
    - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro
  labels:
    traefik.enable: 'true'
    traefik.docker.network: net-traefik
    traefik.http.routers.ltb-wp-http.entrypoints: http
    traefik.http.routers.ltb-wp-http.middlewares: https-redirect
    traefik.http.routers.ltb-wp-http.rule: Host(`wp.mydomain.com`)
    traefik.http.routers.ltb-wp-https.entrypoints: https
    traefik.http.routers.ltb-wp-https.rule: Host(`wp.mydomain.com`)
    traefik.http.routers.ltb-wp-https.tls: 'true'
    traefik.http.routers.ltb-wp-https.tls.options: 'default'
    traefik.http.routers.ltb-wp-https.middlewares: ipfilter,secure-headers,gzip
    traefik.http.services.ltb-wp-https.loadbalancer.server.port: '8080'

Création et utilisation d’un compte de service

Vous avez dû remarquer l’utilisation de cn=manager,dc=MyDomain ici et là. J’ai en effet décidé de créer et d’utiliser un compte de service ayant juste les droits nécessaires pour être utilisés par Self-Service-Password et Service-Desk, et c’est ainsi que j’ai rencontré les ACL LDAP (olcAccess).

Il nous fallait le droit en lecture sur ou=ppolicies et ou=users, ainsi que de pouvoir écrire sur l’attribut userPassword et pwdAccountLockedTime pour ou=users.

J’ai réalisé un petit fichier manager.ldif :

# ldapadd -Y EXTERNAL -H ldapi:/// -f manager.ldif
# Restrict manger to read ou=ppolicies, write on userPassword attribute on ou=users, and read everything else on ou=users
dn: olcDatabase={1}mdb,cn=config
changetype: modify
add: olcAccess
olcAccess: {1}to dn.subtree="ou=ppolicies,dc=MyDomain" by dn="cn=manager,dc=MyDomain" read by * break
-
add: olcAccess
olcAccess: {2}to dn.subtree="ou=users,dc=MyDomain" attr=userPassword,pwdAccountLockedTime by dn="cn=manager,dc=MyDomain" write by * break
-
add: olcAccess
olcAccess: {3}to dn.subtree="ou=users,dc=MyDomain" by dn="cn=manager,dc=MyDomain" read by * break

L’ordre est ici très important car le serveur LDAP lit les règles de façon séquentielles, et dès qu’il en trouve une qui matche, il s’arrête. Ainsi si on avait inversé les deux dernières olcAccess, on aurait eu les droits en lecture, mais pas en écriture sur l’attribut userPassword car il aurait déjà trouvé une permission de lecture, et s’arrête la.

Les indicateurs de positions ({1},{2},{3}) sont également importants, car par défaut il existe un set de règles :

olcAccess: {0}to * by dn.exact=gidNumber=0+uidNumber=0,cn=peercred,cn=extern
 al,cn=auth manage by * break
olcAccess: {1}to attrs=userPassword,shadowLastChange by self write by dn="cn
 =admin,dc=MyDomain" write by anonymous auth by * none
olcAccess: {2}to * by self read by dn="cn=admin,dc=MyDomain" write by dn="cn
 =readonly,dc=MyDomain" read by * none

Et ajouter nos règles à la suite serait inefficace car l’attribut userPassword disposait déjà d’une ACL, et la dernière olcAccess décrit une règle à base de wildcard (*) donc en théorie, toute règle après celle-ci devrait être sans effet.

J’ai mis plusieures heures à comprendre ces quelques subtilités des ACL LDAP, et je ne pense pas les avoir toutes relevées, donc il est très probablement possible de pouvoir faire mieux.

Je me suis basé sur la documentation officielle, ainsi que deux articles de blog qui m’ont permis d’y voir plus clair :

Docker image noxinmortus/docker-ldap-tool-box

J’ai décidé de mutualiser les ressources de ces trois images Docker sur un seul dépôt Git car leur construction est pratiquement identique, et qu’il me paraissait logique de rassembler afin de garantir une meilleure maintenance.

Comme toutes mes images, elles sont basées sur Debian, multi-architectures (ici linux/amd64,linux/arm/v7,linux/arm64), et le plus légères possible (environ ~70MB).

J’ai également permis la mise en place d’une authentification LDAP au niveau d’apache2 afin de restreindre l’accès aux utilisateurs privilégiés avec des variables d’environnement.

Prochain article sur la supervision et la sauvegarde de notre OpenLDAP.

Merci à ma chérie pour la relecture.

A+