Ddevleeschauwer : Page créée avec « {{ Introduction | Cette article permet de mettre en place un serveur OpenLDAP }} == Infrastructure:LDAP == == Berkeley DB == Pour fonctionner, OpenLDAP est basé su... »

2013-03-30T12:12:24Z

Page créée avec « {{ Introduction | Cette article permet de mettre en place un serveur OpenLDAP }} == Infrastructure:LDAP == == Berkeley DB == Pour fonctionner, OpenLDAP est basé su... »

Nouvelle page

{{ Introduction | Cette article permet de mettre en place un serveur OpenLDAP }}

== [[Infrastructure:LDAP]] ==

== Berkeley DB ==

Pour fonctionner, OpenLDAP est basé sur la base de donnée Berkeley

=== Préparation ===

Avant de passer à l'installation de la database, il est nécessaire de réaliser quelque opérations préliminaires
 
{{ Console root | apt-get install libwrap0-dev make gcc openssl libssl-dev libsasl2-2 libsasl2-dev }}
 

=== Installation ===

Pour installer, il nous faut d’abord désarchiver l'archive :
 
{{ Console | tar -xvf db-5.3.21.tar.gz && cd db-5.3.21/build_unix/ && mkdir /opt/Berkeley }}
 
{{ Note | Il est nécessaire de se rendre dans le dossier {{ File | build_unix }} pour réaliser la compilation }}
 
On peux maintenant passer à la compilation :
 
{{ Console root | 1=../dist/configure --prefix=/opt/Berkeley }}
 
* --prefix : permet de spécifier le dossier d'installation
 
Une fois la compilation terminée, on passe à la phase d'installation :
 
{{ Console root | make [root@ordi ~]# make install }}
 
Si aucune erreur n'est signalé, la database Berkely est bien installé

== OpenSSL ==

L'installation d'OpenSSL est nécessaire si l'on veut pouvoir utiliser le protocole SSL pour notre serveur OpenLDAP

=== Téléchargement ===
 
{{ Console | wget http://www.openssl.org/source/openssl-1.0.1c.tar.gz }}
 
{{ Note | La version 1.0.1C est la dernière version lors de l'écriture de cette page }}
 
=== Installation ===

La première étape consiste à désarchiver l'archive téléchargé et de lancer la compilation :
 
{{ Console | tar -xvf openssl-1.0.1c.tar.gz && cd openssl-1.0.1c}}
 
{{Console root | 1=./config shared --openssldir=/usr/local }}
 
* --openssldir : permet de spécifier le répertoire de destination du programme
 
{{ Console root | make [root@ordi ~]# make install }}
 
Si aucune erreur n'est signalé, openssl est bien installé.

== OpenLDAP ==

Maintenant que les composants dont OpenLDAP a besoin sont installé, on va pouvoir passé à son installation et configuration

=== Installation en compilation ===

La première chose à faire est de le télécharger :
 
{{ Console | wget http://www.openldap.org/software/download/OpenLDAP/openldap-release/openldap-2.4.32.tgz }}
 
{{ Note | La version 2.4.32 est la dernière version du logiciel lors de l'écriture de cette page }}
 
On doit, comme pour les autres composants, réaliser la phase de compilation et installation :
 
{{ Console root | 1=tar -xvf openldap-2.4.32.tgz && cd openldap-2.4.32 && mkdir /opt/openldap [root@ordi ~]# ./configure --prefix=/opt/openldap --enable-ldap=yes CPPFLAGS="-I/root/db-5.3.21/build_unix" LDFLAGS="-L/root/db-5.3.21/build_unix" }}
 
Une fois la compilation terminer, on installe les dépendances, openldap en lui-même et on lance les test afin de s'assurer que l'installation se soit bien passé
 
{{ Console root | make depend [root@ordi ~]# make [root@ordi ~]# make test [root@ordi ~]# make install }}

==== Configuration statique ====
===== Configuration de base =====

Pour configurer Openldap de manière statique, il faut éditer le fichier {{ File | /opt/openldap/etc/openldap/slapd.conf }} :
<pre>
#
# See slapd.conf(5) for details on configuration options.
# This file should NOT be world readable.
#
include /opt/openldap/etc/openldap/schema/core.schema
include /opt/openldap/etc/openldap/schema/cosine.schema
include /opt/openldap/etc/openldap/schema/inetorgperson.schema
include /opt/openldap/etc/openldap/schema/nis.schema

# Define global ACLs to disable default read access.

# Do not enable referrals until AFTER you have a working directory
# service AND an understanding of referrals.
#referral ldap://root.openldap.org

pidfile /opt/openldap/var/run/slapd.pid
argsfile /opt/openldap/var/run/slapd.args

#ID
ServerID 001

#Log
loglevel 256

# Load dynamic backend modules:
# modulepath /opt/openldap/libexec/openldap
# moduleload back_bdb.la
# moduleload back_hdb.la
# moduleload back_ldap.la
# moduleload back_monitor.la

# Sample security restrictions
# Require integrity protection (prevent hijacking)
# Require 112-bit (3DES or better) encryption for updates
# Require 63-bit encryption for simple bind
# security ssf=1 update_ssf=112 simple_bind=64

# Sample access control policy:
# Root DSE: allow anyone to read it
# Subschema (sub)entry DSE: allow anyone to read it
# Other DSEs:
# Allow self write access
# Allow authenticated users read access
# Allow anonymous users to authenticate
# Directives needed to implement policy:
# access to dn.base="" by * read
# access to dn.base="cn=Subschema" by * read
# access to *
# by self write
# by users read
# by anonymous auth
#
# if no access controls are present, the default policy
# allows anyone and everyone to read anything but restricts
# updates to rootdn. (e.g., "access to * by * read")
#
# rootdn can always read and write EVERYTHING!

#######################################################################
# BDB database definitions
#######################################################################

database hdb
suffix "dc=pass,dc=be"
rootdn "cn=root,dc=pass,dc=be"
# Cleartext passwords, especially for the rootdn, should
# be avoid. See slappasswd(8) and slapd.conf(5) for details.
# Use of strong authentication encouraged.
rootpw secret
# The database directory MUST exist prior to running slapd AND
# should only be accessible by the slapd and slap tools.
# Mode 700 recommended.
directory /opt/openldap/var/openldap-data
# Indices to maintain
index objectclass,entryCSN,entryUUID eq

database monitor
rootdn "cn=admin,cn=Monitor"
rootpw "password"
access to dn.subtree="cn=Monitor"
by dn.exact="cn=root,cn=Monitor" write
by users read
by * none

</pre>
TODO : expliquer les différents points
 

===== Création de la racine =====

Pour créer la racine de notre annuaire, on doit créer un fichier au format LDIF pour l'injecter par la suite, le fichier racine ressemble à ceci :
<pre>
# Top-level object in domain
dn: dc=pass,dc=be
objectClass: top
objectClass: dcObject
objectClass: organization
o: pass.be
dc: pass
description: LDAP Example

# Admin user
#dn: cn=root,dc=pass,dc=be
#objectClass: simpleSecurityObject
#objectClass: organizationalRole
#cn: root
#description: LDAP administrator
#userPassword: secret
</pre>
TODO : Expliquer vite fait le fichier
 
Il nous faut injecter le fichier via la commande suivante :
 
{{ Console | 1=ldapadd -xvD "cn=root,dc=pass,dc=be" -w secret -f racine.ldif -H ldap://192.168.100.34:389 }}
 
TODO : expliquer les paramètres

==== Démarrer/Arrêter ====

===== Démarrer OpenLDAP =====

Pour démarrer le serveur OpenLDAP en configuration statique, on utilise la commande suivante :
 
{{ Console | /opt/openldap/libexec/slapd -f /opt/openldap/etc/openldap/slapd.conf -h ldap://192.168.100.34:389 }}
 
{{ Note | -h ldap://192.168.100.34:389 est à modifier selon l'adresse IP du serveur }}
 
===== Arrêter OpenLDAP =====

Pour arrêter le serveur OpenLDAP, il faut kileer le process avec le numero d'ID fournit dans le fichier {{ File | /opt/openldap/var/run/slapd.pid }} :
 
{{ Console root | kill -INT `cat /opt/openldap/var/run/slapd.pid` }}
 

===== Script d'automatisation =====

<syntaxhighlight lang="bash">
#! /bin/bash
# Auteur : Devleeschauwer Denis
# Slapd start script
#
# Juillet 2012
#

#GLOBAL VARIABLES
DIRECTORY=/opt/openldap
APPLICATION=OpenLDAP
IP=ldap://192.168.100.34:389

######################################################################
##########################Function####################################
######################################################################
start ()
{
#Commande pour demmarer slapd
$DIRECTORY/libexec/slapd -f $DIRECTORY/etc/openldap/slapd.conf -h $IP

if [ $? -eq 0 ]
then
echo "Start $APPLICATION Instance [OK]"
else
echo "Start $APPLICATION Instance [KO]"
fi
}

stop ()
{
#Commande pour arreter ProFTPD
kill -INT `cat $DIRECTORY/var/run/slapd.pid` > /dev/null 2>&1
if [ $? -eq 0 ]
then
echo "Stop $APPLICATION Instance [OK]"
else
echo "Stop $APPLICATION Instance [KO]"
fi
}

restart ()
{
stop
sleep 5
start
}

case "$1" in

'start')
start
;;

'stop')
stop
;;

'restart')
stop
sleep 5
start
;;

'status')
cat $DIRECTORY/var/run/slapd.pid > /dev/null 2>&1

if [ $? -eq 0 ]
then
echo "$APPLICATION Instance Running"
else
echo "$APPLICATION Instance Stop"
fi
;;

*)
echo "Usage: $0 { start | stop | restart | status }"
exit 1
;;

esac

exit $?
</syntaxhighlight>
 

=== Installation en package ===

Avant d'installer OpenLDAP, il faut installer les dépendances nécessaire :
 
{{ Console root | apt-get install libdb-dev openssl libssl-dev libsasl2-2 libsasl2-dev }}
 
Pour installer le serveur OpenLDAP ainsi que les outils clients :
 
{{ Console root | apt-get install ldapvi ldap-utils slapd }}
 
Pour plus de faciliter, on opeux créer des alias dans le fichier {{ File | .bashrc }}
<pre>
alias cn-config='ldapvi -Y external -h ldapi:/// -b cn=config'
alias cn-pass='ldapvi -Y external -h ldapi:/// -b dc=be'
</pre>

==== Configuration ====

Pour configurer la base de notre serveur OpenLDAP, il suffit de reconfigurer le paquet {{ File | slapd }} que l'on a installé et de répondre aux différents questions :
 
{{ Console root | dpkg-reconfigure slapd }}
 
On va changer le mot de passe de l'utilisateur "cn=admin,cn=config"
<pre>
slappasswd
New password:
Re-enter new password:
{SSHA}0z/qm5CpdcJiJRz2tiC/0KNlxGe5s7ne
</pre>
On copie le mot de passe crypté que l'on va rajouter à la config avec la commande :
 
{{ Console root | 1=ldapvi -Y external -h ldapi:/// -b cn=config }}
 
On modifie l'entrée "cn=config" pour rajouter le mot de passe
<pre>
olcDatabase={0}config,cn=config
objectClass: olcDatabaseConfig
olcDatabase: {0}config
olcAccess: {0}to * by dn.exact=gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth manage by * break
olcRootDN: cn=admin,cn=config
olcRootPW: {SSHA}0z/qm5CpdcJiJRz2tiC/0KNlxGe5s7ne
</pre>

=== Réplication ===

==== Mode Provider/Consumer ====

===== Provider =====

Avant de pouvoir configurer notre provider, il faut charger le module syncprov

Créons le fichier LDIF suivant :

<pre>
#Load the syncprov and accesslog modules.
dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: syncprov
-
add: olcModuleLoad
olcModuleLoad: accesslog
</pre>
 
Pour ajouter charger le ficher dans la config :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/syncprov.ldif }}
 

Une fois le module syncprov chargé, il faut configurer la database que l'on souhaite répliquer en créant un fichier LDIF :

<pre>
dn: olcOverlay=syncprov,olcDatabase={1}hdb,cn=config
changetype: add
objectClass: olcOverlayConfig
objectClass: olcSyncProvConfig
olcOverlay: syncprov
olcSpNoPresent: TRUE
olcSpCheckPoint: 100 1
</pre>

* olcSpCheckPoint: Réplication après 100 modifications ou toutes les 1 minutes
 
Il suffit de charger le fichier LDIF créée :
Pour ajouter charger le ficher dans la config :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/syncprov-hdb.ldif }}
 

===== Consumer =====

Comme pour le Provider, il est nécessaire de charger le module syncprov :

<pre>
#Load the syncprov and accesslog modules.
dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: syncprov
-
add: olcModuleLoad
olcModuleLoad: accesslog
</pre>
 
Pour ajouter charger le ficher dans la config :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/syncprov.ldif }}
 

Il faut maintenant configurer la database coté consummer
<pre>
dn: olcDatabase={1}hdb,cn=config
changetype: modify
add: olcDbIndex
olcDbIndex: entryUUID eq
-
add: olcDbIndex
olcDbIndex: entryCSN eq
-
add: olcSyncRepl
olcSyncrepl: {0}rid=003 provider=ldap://192.168.168.32:389 type=refreshAndPersist retry="5 10 300 +" searchbase="dc=be" attrs="*,+" bindmethod=simple binddn="cn=admin,dc=be" credentials=multi/2004
-
add: olcUpdateRef
olcUpdateRef: ldap://192.168.168.32

</pre>

* rid=001 : Définition du “rid ” (l’identifiant unique du serveur esclave dans la chaîne de réplication)
* provider=ldap://192.168.100.50:389 : Adresse du « provider ». Si le port d’écoute n'est pas indiqué, celui par défaut du protocole ldap, le 389 sera utilisé
* type=refreshAndPersist : Définition du type de réplication utilisé
* retry="5 10 300 +" : L’esclave tentera de se reconnecter au maitre toutes les 5 secondes les 10 premières tentatives, ensuite toutes les 5 minutes (300 secondes) indéfiniment (“+”)
* searchbase="dc=be" : Définit la branche à répliquer. Dans ce cas, la branche est l'annuaire au complet
* attrs="*,+" : Sélectionne les attributs à répliquer. Ici, tous les attributs sont sélectionnés (valeur par défaut)
* bindmethod=simple : Indique le type d'authentification à utilisé (simple ou sasl)
* binddn="cn=admin,dc=be" credentials=abcde :

Une fois le fichier construit, il nous suffit de le rajouter :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/refreshAndPersist.ldif }}
 

==== Mode Mirror ====

Créons le fichier LDIF suivant :
<pre>
#Load the syncprov and accesslog modules.
dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: syncprov
-
add: olcModuleLoad
olcModuleLoad: accesslog
</pre>
 
Pour ajouter charger le ficher dans la config :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/syncprov.ldif }}
 

Le Mirror Mode va permettre de de synchroniser nos 2 serveurs OpenLDAP Provider ensemble. Pour ce faire, nous allons créer un fichier LDIF que l'on va appliquer à nos 2 Provider :
 
<pre>
dn: cn=config
changetype: modify
replace: olcServerID
olcServerID: 1 ldap://192.168.100.50
olcServerID: 2 ldap://192.168.100.51

dn: olcDatabase={0}config,cn=config
changetype: modify
add: olcSyncrepl
olcSyncrepl: rid=001 provider=ldap://192.168.100.50 binddn="cn=admin,cn=config" bindmethod=simple
credentials=abcde searchbase="cn=config" type=refreshAndPersist
retry="5 5 300 5" timeout=1
olcSyncrepl: rid=002 provider=ldap://192.168.100.51 binddn="cn=admin,cn=config" bindmethod=simple
credentials=abcde searchbase="cn=config" type=refreshAndPersist
retry="5 5 300 5" timeout=1
-
add: olcMirrorMode
olcMirrorMode: TRUE
</pre>
 

* olcServerID : Correspond à nos 2 Provider. Si nous en avions plus, il suffirait de les rajouter
* olcSyncrepl : Correspond à un des noeuds de réplications des provider
* olcMirrorMode : Permet d'activer la fonctionnalité de mirroir

 
{{ Avertissement | N'oubliez pas de modifier les IP/Hosts, login et password selon la config }}
 

Pour ajouter le fichier au serveur, on utilis ela commande '''ldapmodify''' :
 
{{ Console root | 1=ldapmodify -x -D cn=admin,cn=config -W -f syncrepl_cn-config.ldif }}
 
Il faut faire de même sur les autres Providers. Comme on a ajouté un nouveau module, on doit redémarrer les serveurs :
 
{{ Console root | /etc/init.d/slapd restart }}
 
Maintenant, on peux passer à la configuration de la réplication de la database. Comme la configuration des serveur est déja activé, il n'ets pas nécessaire de répéter l'opréation ci-dessous sur les autres serveurs.

On crée donc le fichier LDIF qui va servir à configurer la database :
 
<pre>
dn: olcDatabase={1}hdb,cn=config
add: olcSyncRepl
olcSyncRepl: rid=003 provider=ldap://192.168.100.50 binddn="cn=admin,dc=be"
bindmethod=simple credentials=abcde searchbase="dc=be" type=refreshAndPersist
retry="5 5 300 5" timeout=1
olcSyncRepl: rid=004 provider=ldap://192.168.100.51 binddn="cn=admin,dc=be"
bindmethod=simple credentials=abcde searchbase="dc=be" type=refreshAndPersist
retry="5 5 300 5" timeout=1
-
add: olcMirrorMode
olcMirrorMode: TRUE

dn: olcOverlay=syncprov,olcDatabase={1}hdb,cn=config
changetype: add
objectClass: olcOverlayConfig
objectClass: olcSyncProvConfig
olcOverlay: syncprov
olcSpCheckpoint: 100 1
olcSpNoPresent: TRUE
</pre>
 
On ajoute le fichier via la commande '''ldapmodify''' :
 
{{ Console root | 1=ldapmodify -x -D cn=admin,cn=config -W -f mirrorHdb.ldif }}
 
Normalement la configuration est terminée. Modifier une entrée sur un des serveurs et vérifier si celle-ci est bien répliqué sur l'autre provider

==== Redirection requête ====

La redirection de requête d'écriture du Consumer vers le Provider est réalisé via le module/Overlay chain. Avant de pouvoir le configurer, il est nécessaire de chargé un module (sur le consumer).

On crée le fichier LDIF suivant :
 
<pre>
#Load the chain modules.
dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: back_ldap
</pre>
 
Ensuite, on ajoute ce fichier :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/moduleChainLoad.ldif }}
 

Une fois, le module {{ File | back_ldap }} chargé, on peux passer à la configuration du module chain

On crée le fichier LDIF suivant afin de charger le module chain dans le frontend de notre LDAP:
 
<pre>
dn: olcOverlay=chain,olcDatabase={-1}frontend,cn=config
changetype: add
objectClass: olcOverlayConfig
objectClass: olcChainConfig
olcOverlay: {0}chain
olcChainReturnError: TRUE
</pre>
 
Ensuite, on ajoute ce fichier :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/chain.ldif }}
 
Le module chain est chargé dans le frontend. Il nous reste plus qu'a le charger/configurer pour notre database. On passe toujours via un fichier LDIF :
 
<pre>
dn: olcDatabase={0}hdb,olcOverlay={0}chain,olcDatabase={-1}frontend,cn=config
changetype: add
objectClass: olcLDAPConfig
objectClass: olcChainDatabase
olcDatabase: {0}hdb
olcDbURI: "ldap://debprovldapsrv.server.pass.be"
olcDbRebindAsUser: TRUE
olcDbIDAssertBind: bindmethod=simple
binddn="cn=admin,dc=be"
credentials=multi/2004
mode=self
olcDbIDAssertAuthzFrom: "*"

dn: olcDatabase={1}hdb,olcOverlay={0}chain,olcDatabase={-1}frontend,cn=config
changetype: add
objectClass: olcLDAPConfig
objectClass: olcChainDatabase
olcDatabase: {1}hdb
olcDbURI: "ldap://debprovldapsrv.server.pass.be"
olcDbRebindAsUser: TRUE
olcDbIDAssertBind: bindmethod=simple
binddn="cn=admin,dc=be"
credentials=multi/2004
mode=self
olcDbIDAssertAuthzFrom: "*"
</pre>
 
{{ Avertissement | 1=On a ajouté 2 entrées à l'overlay chain parce qu’apparemment, il faut absolument que le numéro de hdb correspondant au numéro de la hdb dans cn=config }}
 
Ensuite, on ajoute ce fichier :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f LDIF/chainConfigHdb.ldif }}
 
Il nous reste a configurer le provider

On doit rajouter un attribut au schema cn=config. On peux le rajouter via la commande ldapvi :
 
{{ Console root | 1=ldapvi -Y external -h ldapi:/// -b cn=config }}
 
On rajoute l'attribut: "olcAuthzPolicy: to".
Cette directive permet une authentification auprès du serveur provider avec un identifiant donné, puis d'utiliser l'identifiant référence par la valeur de l'attribut authzTo de cette entrée pour la détermination des droits d'accès.
<pre>
dn: cn=config
changetype: modify
add: olcAuthzPolicy
olcAuthzPolicy: to
</pre>
 
{{ Console root | ldapmodify -QY EXTERNAL -H ldapi:/// -f olc-AuthzPolicy.ldif }}
 

On peux maintenant créé un utilisateur spécifique pour la redirection de requête :
 
<pre>
dn: cn=chain,dc=be
objectClass: organizationalRole
objectClass: simpleSecurityObject
cn: chain
userPassword: {SSHA}Abr//HGJApKzK91ilOhXGEcwaLlJxdfw
description: slave server proxy user
authzTo: dn:*
</pre>
 

== TLS ==

=== Création du certificat ===
Il peut être plus qu'intéressant de sécuriser les échanges entre les clients LDAP et le serveur à l'aide du protocole SSL. En effet, les mots de passe des comptes admin et utilisateurs passent en clair lors des échanges avec pam_ldap et nss_ldap
On doit générer un certificat comme suit (ce certificat peut aussi servir à apache pour sécuriser l'utilisation de phpldapadmin) :
 
{{ Console | openssl req -newkey rsa:1024 -x509 -nodes -out server.pem -keyout server.pem -days 365 }}
 
* rsa:1024 : Générer une clé RSA crypté sur 1024 bits
* -out : certificat de sortie
* -keyout : clé du certificat. Dans ce cas-ci le même fichier
* -days : le nombre de jours de validité. Ici 1 ans

Il est conseillé :

* de mettre le FQDN (Fully Qualified Domain Name) du serveur dans le « Common Name » : exemple « provider1.admin.pass.be »

=== Configuration LDAPS ===

On crée un dossier pour accueillir le/les certificats :
 
{{ Console root | mkdir /etc/ldap/ssl && chown openldap:openldap /etc/ldap/ssl [root@ordi ~]# mv server.pem /etc/ldap/ssl }}
 
Créer un fichier {{ File | tls_ldap.ldif }} contenant les références aux certificat :
 
<pre>
dn: cn=config
add: olcTLSCACertificateFile
olcTLSCACertificateFile: /etc/ldap/ssl/server.pem
-
add: olcTLSCertificateFile
olcTLSCertificateFile: /etc/ldap/ssl/server.pem
-
add: olcTLSCertificateKeyFile
olcTLSCertificateKeyFile: /etc/ldap/ssl/server.pem
</pre>
 
On ajoute la configuration au serveur LDAP :
 
{{ Console root | ldapmodify -Y EXTERNAL -H ldapi:// -f tls_ldap.ldif }}
 
On modifie le fichier {{ File | /etc/default/slapd }} pour n'autoriser que le ldaps, ou éventuellement les deux :
 
<pre>
# slapd normally serves ldap only on all TCP-ports 389. slapd can also
# service requests on TCP-port 636 (ldaps) and requests via unix
# sockets.
# Example usage:
# SLAPD_SERVICES="ldap://127.0.0.1:389/ ldaps:/// ldapi:///"
SLAPD_SERVICES="ldapi:/// ldaps:///"
</pre>
 
On modifie également le fichier {{ File | /etc/ldap/ldap.conf }} :
 
<pre>
#BASE dc=example,dc=com
#URI ldap://ldap.example.com ldap://ldap-master.example.com:666
URI ldaps://provider1.admin.pass.be

#SIZELIMIT 12
#TIMELIMIT 15
#DEREF never
tls_cacert /etc/ldap/ssl/provider1.pem
tls_checkpeer no
</pre>
 
Redémarrer le service :
 
{{ Console root | /etc/init/d/slapd restart }}
 
Si on réalise un nmap sur notre serveur, on doit recevoir une sortie console de ce genre :
<pre>
22/tcp open ssh
139/tcp open netbios-ssn
389/tcp open ldap
445/tcp open microsoft-ds
636/tcp open ldapssl
</pre>
* 389 : si on a décider de laisser le protocole ldap
* 636 : le port du protocole ldaps est bien ouvert

=== Réplication TLS ===

Pour répliquer en TLS, il est nécessaire de transférer les certificats entre machines.

Si la réplication est réaliser entre provider1 et provider2.
provider1 doit avoir dans le dossier {{ File | /etc/ldap/ssl }} :
* provider1.pem
* provider2.pem
Vice-versa

==== Mirror Mode ====

Il est nécessaire de remplacer dans {{ File | 1=cn=config }} toutes les adresses IP des serveurs au format '''ldaps://serveur.domaine''' ( ex: ldaps://provider1.admin.pass.be )

===== Réplication config =====
 
<pre>
olcDatabase={0}config,cn=config
objectClass: olcDatabaseConfig
olcDatabase: {0}config
olcAccess: {0}to * by dn.exact=gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth manage by * break
olcRootDN: cn=admin,cn=config
olcRootPW: {SSHA}IfaBRNrAwCCmYOQVABHCM6PbnQ4UkdAF
olcSyncrepl: {0}rid=001 provider=ldaps://provider1.admin.pass.be binddn="cn=admin,cn=config" bindmethod=simple credentials=abcde searchbase="cn=config" type=refreshAndPersist retry="5 5 300 5" timeout=1 starttls=yes tls_cacert=/etc/ldap/ssl/provider1.pem
olcSyncrepl: {1}rid=002 provider=ldaps://provider2.admin.pass.be binddn="cn=admin,cn=config" bindmethod=simple credentials=abcde searchbase="cn=config" type=refreshAndPersist retry="5 5 300 5" timeout=1 starttls=yes tls_cacert=/etc/ldap/ssl/provider2.pem
olcMirrorMode: TRUE
</pre>
 

===== Réplication database =====
 
<pre>
olcDatabase={1}hdb,cn=config
objectClass: olcDatabaseConfig
objectClass: olcHdbConfig
olcDatabase: {1}hdb
olcDbDirectory: /var/lib/ldap
olcSuffix: dc=be
olcAccess: {0}to attrs=userPassword,shadowLastChange by self write by anonymous auth by dn="cn=admin,dc=be" write by * none
olcAccess: {1}to dn.base="" by * read
olcAccess: {2}to * by self write by dn="cn=admin,dc=be" write by * read
olcLastMod: TRUE
olcRootDN: cn=admin,dc=be
olcRootPW: {SSHA}iJUIRv9XoJIXvyTW9WZEQlwNwZYkvrGF
olcSyncrepl: {0}rid=003 provider=ldaps://provider1.admin.pass.be binddn="cn=admin,dc=be" bindmethod=simple credentials=abcde searchbase="dc=be" type=refreshAndPersist retry="5 5 300 5" timeout=1 starttls=yes tls_cacert=/etc/ldap/ssl/provider1.pem
olcSyncrepl: {1}rid=004 provider=ldaps://provider2.admin.pass.be binddn="cn=admin,dc=be" bindmethod=simple credentials=abcde searchbase="dc=be" type=refreshAndPersist retry="5 5 300 5" timeout=1 starttls=yes tls_cacert=/etc/ldap/ssl/provider2.pem
olcMirrorMode: TRUE
olcDbCheckpoint: 512 30
olcDbConfig: {0}set_cachesize 0 2097152 0
olcDbConfig: {1}set_lk_max_objects 1500
olcDbConfig: {2}set_lk_max_locks 1500
olcDbConfig: {3}set_lk_max_lockers 1500
olcDbIndex: entryCSN eq
olcDbIndex: entryUUID eq
olcDbIndex: objectClass eq
</pre>
 
==== Provider/consummer ====
{{ Avertissement | Il est nécessaire de distribuer le certificats du provider sur le consummer }}
 
Il faut modifier la config concernant la database pour qu'elle ressemble à ceci :
 
<pre>
olcSyncrepl: {0}rid=003 provider=ldaps://provider1.admin.pass.be type=refreshAndPersist retry="5 10 300 +" searchbase="dc=be" attrs="*,+" bindmethod=simple binddn="cn=admin,dc=be" credentials=abcde starttls=yes tls_cacert=/etc/ldap/ssl/provider1.pem
olcUpdateRef: ldaps://provider1.admin.pass.be
</pre>
 
Ici, le consumer se synchronise avec provider1.admin.pass.be

==== Redirection requêtes ====

Modifier la config, pour qu'elle essemble à ceci :
 
<pre>
olcDatabase={0}ldap,olcOverlay={0}chain,olcDatabase={-1}frontend,cn=config
objectClass: olcLDAPConfig
objectClass: olcChainDatabase
olcDatabase: {0}ldap
olcDbURI: "ldaps://provider1.admin.pass.be"
olcDbIDAssertBind: bindmethod=simple binddn="cn=admin,dc=be" credentials=abcde mode=self starttls=yes tls_cacert=/etc/ldap/ssl/provider1.pem
olcDbIDAssertAuthzFrom: {0}*
olcDbIDAssertAuthzFrom: {1}"*"
olcDbRebindAsUser: TRUE

olcDatabase={1}hdb,olcOverlay={0}chain,olcDatabase={-1}frontend,cn=config
objectClass: olcLDAPConfig
objectClass: olcChainDatabase
olcDatabase: {1}hdb
olcDbURI: "ldaps://provider1.admin.pass.be"
olcDbIDAssertBind: bindmethod=simple binddn="cn=admin,dc=be" credentials=abcde mode=self starttls=yes tls_cacert=/etc/ldap/ssl/provider1.pem
olcDbIDAssertAuthzFrom: {0}"*"
olcDbRebindAsUser: TRUE
</pre>
 

Dans ce cas ci, le consumer redirige les requêtes vers '''provider1.admin.pass.be'''

== Monitoring ==
=== Instanciation ===
Pour utiliser la database Monitor, il est nécessaire d'ajouter le module '''back_monitor''' à notre annuaire.
On crée le fichier {{ File | back_monitor.ldif }} :
<pre>
dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: back_monitor
</pre>
On ajoute ensuite ce fichier :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f back_monitor.ldif }}
 
Maintenant que le module est chargé, on peux créer la database Monitor
<pre>
olcDatabase=Monitor,cn=config
objectClass: olcDatabaseConfig
olcDatabase: monitor
olcAccess: {0}to dn.subtree="cn=monitor" by * read
olcRootDN: cn=admin,cn=monitor
olcRootPW: {SSHA}xqc5cwu6jkSDCcXYl7L68ibHlSb7Azx0
</pre>
On ajoute le fichier :
 
{{ Console root | ldapadd -Y external -H ldapi:/// -f monitorDB.ldif }}
 

=== Interroger Monitor ===

Pour récupérer les informations de monitoring, il suffit de réaliser une requête sur la database monitor.
Exemple :
 
{{ Console | 1=ldapsearch -xvD 'cn=admin,cn=monitor' -w abcde -h localhost -b "cn=Total,cn=Connections,cn=monitor" 'monitorCounter' }}
 
Cette requête permet de récupérer le nombre total de connections à notre annuaire

== OpenLDAP PDC ==

Suivre [[OpenLDAP-PDC|cette page]]

== Authentification Linux ==

=== installation ===

Commençons par installer le paquet suivant :

{{ Console root | apt-get install nslcd }} 

Voici ce qu'il faut répondre aux questions (à adapter en fonction de votre serveur bien sûr) :

<PRE>
URI du serveur LDAP : ldap://serveur ldap
Base de recherche du serveur LDAP : dc=pass, dc=be
Cochez les case suivant group,passwd,shadow
</PRE>

Pour que le Home Directory d'un utilisateur soit crée lors de son premier accès installer le paquet suivant.

{{ Console root | apt-get install libpam-mklocaluser }} 

Si vous voulez que le home paramétré dans votre LDAP soit créé lors de la 1ère connexion de votre utilisateur, ajoutez cette ligne au fichier {{ File | /etc/pam.d/common-session }} :
<pre>
session required pam_mkhomedir.so skel=/etc/skel umask=0022
</pre>

=== Troubleshouting ===

afin de tester le bon fonctionnement commencer par faire:

{{ Console root | getent passwd }} 
pour lister les utilisateurs connus sur le serveur

{{ Console root | getent group }} 
pour lister les groupes connus sur le serveur

En suite, se logger en tant qu'utilisateur ldap pour vérifier la création home de l'utilisateur.

{{ Avertissement | Le home directory de l'utilisateur sera créé en référence du chemin se trouvant dans le champ "Home directory" du serveur LDAP. 
il ne sera pas nécessairement dans le répertoire /home }}

{{ note | 1=l'utilisateur authentifier ne disposera pas des droits administrateurs par défaut. 
pour les admins il suffira d'être dans le groupe Domain Admins et d'ajouter dans le fichier /etc/sudoers la ligne suivante : '''%Domain\ Admins ALL=(ALL) ALL''' }} 

{{ Avertissement | Le groupe Domain Admins est un groupe qui peut constituer une faille de sécurité, s’il n’est pas utilisé à bon escient. }}

== Procédures ==

=== Ajout d'un schéma existant ===

Pour ajoutez un schéma déja présent sur le serveur LDAP. Dans un terminal tapez:
 
{{ Console root | ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/nomSchema.ldif }}
 
{{ Note | 1='''nomSchema.ldif''' correspond au schéma que vous voulez rajouter. Exemple : '''[[misc.ldif]]''' }}
 

=== Ajout d'un schéma personnel ===

Pour ajouter un schéma personnel, il faut rentré la commande suivante :
 
{{ Console root | 1=ldapvi --class olcSchemaConfig -Y external -h ldapi:/// -b cn=schema,cn=config }}
 
Et réalisé le fichier comme suit :
<pre>
cn=pass,cn=schema,cn=config
cn: Pass
olcAttributeTypes: {0}( 1.3.6.1.4.1.4203.666.1.90 NAME 'codePrinter' DESC 'Code d utilisation des imprimantes' EQUALITY integerMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.27{4} )
olcAttributeTypes: {1}( 1.3.6.1.4.1.4203.666.1.91 NAME 'imapLogin' DESC 'Login compte/applications IMAP' EQUALITY caseIgnoreMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )
olcObjectClasses: {0}( 1.3.6.1.4.1.4203.666.1.100 NAME 'PASS' DESC 'Schema propre au PASS' SUP top AUXILIARY MUST ( cn $ codePrinter ) MAY ( imapLogin ))
</pre>
 

=== Backup/Restore ===

==== Backup ====

Pour sauvegarder l'annuaire, on exporte le contenu dans un fichier LDIF :
 
{{ Console root | 1=slapcat -F /etc/ldap/slapd.d -b "dc=be" > bckPass.ldif }}
 
* -F : Indique le dossier de la config cn=config
* -b : Indique la base de l'export; Dans ce cas ci, on exporte tous l'annuaire
* > : Redirection de la sortie standard vers le fichier indiqué
 
{{ Note | On n'indique pas d'authentification car on se trouve sur le serveur même en tant que root pour réaliser l'exportation }}
 
==== Restore ====

Avant de réaliser une restauration, il faut '''absolument''' que le service soit coupé et supprimer du fichier de restauration toutes les entrées déjà existantes.
 
{{ Console root | slapadd -l bckPass.ldif -F /etc/ldap/slapd.d }}
 
{{ Avertissement | Assurez vous d'avoir charger les schémas nécessaire au préalable }}
 
[[Catégorie:Linux]]
[[Catégorie:Système]]

← Version précédente		Version du 30 mars 2013 à 12:12
Ligne 1 :		Ligne 1 :
	{{ Introduction \| Cette article permet de mettre en place un serveur OpenLDAP }}		{{ Introduction \| Cette article permet de mettre en place un serveur OpenLDAP }}
−
−	~~== [[Infrastructure:LDAP]] ==~~

	== Berkeley DB ==		== Berkeley DB ==

OpenLDAP - Historique des versions

Ddevleeschauwer : /* Installation en package */

Ddevleeschauwer : /* Script d'automatisation */

Ddevleeschauwer : /* Infrastructure:LDAP */

Ddevleeschauwer : Page créée avec « {{ Introduction | Cette article permet de mettre en place un serveur OpenLDAP }} == Infrastructure:LDAP == == Berkeley DB == Pour fonctionner, OpenLDAP est basé su... »

@@ Ligne 317 : / Ligne 317 : @@
 <pre>
 alias cn-config='ldapvi -Y external -h ldapi:/// -b cn=config'
-alias cn-pass='ldapvi -Y external -h ldapi:/// -b dc=be'
+alias cn-diouxx='ldapvi -Y external -h ldapi:/// -b dc=be'
 </pre>

@@ Ligne 229 : / Ligne 229 : @@
 DIRECTORY=/opt/openldap
 APPLICATION=OpenLDAP
-IP=ldap://192.168.100.34:389
+IP=ldap://IP:PORT
 ######################################################################