MoinMoin : fonctionnement de l'authentification

Historiquement, l'authentification des utilisateurs de MoinMoin est réalisée à l'aide des cookies : lorsque vous vous identifiez, MoinMoin définit un cookie et l'utilise pour vous authentifier — jusqu'à ce que vous vous déconnectiez et que le cookie soit effacé (ou jusqu'à son expiration).

Lorsque MoinMoin est utilisé en environnement professionnel, cette solution n'est en général pas adaptée, car le respect des restrictions d'accès doit être assuré. Depuis la version 1.3, lorsqu'il est utilisé avec certains serveurs web compatibles (comme Apache), MoinMoin peut aussi utiliser l'authentification HTTP de base.

Depuis la version 1.2, MoinMoin dispose d'un système d'authentification librement configurable et offrant une certaine modularité. L'option de paramétrage auth permet de définir la liste des méthodes d'authentification utilisées et leur ordre d'application.

Lorsque vous utilisez une base de données externes d'utilisateurs, vous n'avez pas besoin de créer à la main tous les comptes utilisateurs. En effet, depuis la version 1.5 de MoinMoin, il est possible d'utiliser l'option de paramétrage user_autocreate. Lorsque vous définissez à True (« vrai ») la valeur de cette variable, un nouveau profil utilisateur sera créé automatiquement chaque fois qu'un nouvel utilisateur s'identifiera (et à condition que la méthode d'authentification permette l'auto-création).

Actuellement, il est possible d'utiliser les méthodes d'authentification suivantes :

• Configuration du serveur	Authentification	Méthode d'authentification dans MoinMoin
  Toutes	par MoinMoin avec ses propres cookies	MoinMoin.auth.moin_cookie
  	par MoinMoin avec des cookies externes	voir contrib/auth_externalcookie/
  Apache avec CGI, modpy ou FastCgi	par les modules Apache : HTTP Basic, HTTP Digest, SSPI (alias NTLM) ou LDAP	MoinMoin.auth.http
  	par moin via LDAP	MoinMoin.auth.ldap_login (doit être combiné avec moin_cookie pour garder les informations de session)
  Apache+SSL avec CGI, modpy or FastCgi	par Apache via un certificat client SSL	MoinMoin.auth.sslclientcert
  Twisted	HTTP Basic (mais ne requiert pas encore d'authentification par entête, et n'est donc pour le moment utile juste que pour les opérations automatisées, pas pour l'exploration)	MoinMoin.auth.http
  IIS	(?)	(?)

Autres méthodes d'authentification

Celles-ci ne sont pas à proprement parler des méthodes d'authentification, puisqu'elles n'authentifient pas des utilisateurs, mais utilisent des informations issues de l'authentification à d'autres fins :

• MoinMoin.auth.log	enregistre juste les connexions/déconnexions/noms, et rien d'autre
  MoinMoin.auth.smb_mount	monte des partage smb en utilisant les noms d'utilisateur/mots de passe lors de la connexion, les démonte à la déconnexion

MoinMoin.auth.interwiki n'est pas terminé, le code est expérimental - ne pas utiliser.

Greffons embarqués

moin_cookie auth (par défault)

   1     from MoinMoin.auth import moin_cookie
   2     auth = [moin_cookie]

Ceci est la liste par défaut que moin utilise (et donc si c'est que vous voulez, vous n'aurez rien à configurer). Cela signifie que moin tente juste d'utiliser le cookie MOIN_ID comme il l'a toujours fait.

Pour faire cela, moin va appeler la fonction MoinMoin.auth.moin_cookie. Cette fonction va regarder si un cookie valide existe :

• Si oui, elle va l'utiliser pour créer et retourner un objet utilisateur valide. L'utilisateur est désormais connu.
• Sinon, la fonction ne retournera pas d'objet utilisateur. Comme moin_cookie est la seule méthode d'authentification de la liste, il n'y a pas d'autres méthodes à essayer et l'utilisateur restera dans ce cas inconnu.

http auth

Pour activer l'authentification http vous devez ajouter les lignes suivantes dans wikiconfig.py :

   1     from MoinMoin.auth import http
   2     auth = [http]

Lorsque l'authentification HTTP basic est utilisée avec un serveur web comme Apache, le serveur web prend en charge l'authentification avant que moin ne soit appelé. Soit vous entrez des noms d'utilisateur et mots de passe valides, soit l'accès au serveur web vous est interdit.

La méthode d'authentification http de moin va donc juste vérifier que l'authentification a eu lieue :

• si oui, elle va retourner un objet utilisateur basé sur le nom d'utilisateur qui vient d'être authentifié.
• sinon, elle ne retournera pas d'objet utilisateur. Dans cet exemple, il n'y a pas d'autres méthodes d'authentification, l'utilisateur restera donc inconnu.

En pratique c'est un peu plus compliqué :

• Pour Twisted on utilise le nom d'utilisateur et le mot de passe enregistré dans le profil. A l'exception de l'utilisation du xmlrpc du wiki, ceci n'est pas encore utilisé.
• Pour NTLM et Negotiate, on sépare tout jusqu'au dernier "\" (il s'agit en général du "Nom de domaine\Nom d'utilisateur") et on utilise aussi title() pour normaliser "username" à "Username".

  Couramment on souhaite utiliser user_autocreate = True pour cette méthode d'authentification. moin va alors automatiquement créer un profil utilisateur si l'utilisateur qui vient de s'identifier n'en possède déjà pas un. Ainsi l'utilisateur n'a pas besoin de le créer lui-même.

sslclientcert auth

Pour activer l'authentification à l'aide de certificats SSL clients, vous devez ajouter les lignes suivantes dans wikiconfig.py :

   1     from MoinMoin.auth import sslclientcert
   2     auth = [sslclientcert]

Pour l'authentification avec certificats SSL clients utilisée avec un serveur web comme Apache, le serveur web gère l'authentification avant que moin ne soit appelé. Soit vous avez un certificat SSL client valide, soit votre accès sera refusé au serveur web.

Bref la méthode authentification sslclientcert de moin va juste vérifier si l'authentification a eue lieu :

• si oui, elle va retourner un objet utilisateur valide basé sur l'adresse email ou le nom d'utilisateur du certificat.
• sinon, elle ne retournera pas d'objet utilisateur. Dans cet exemple, il n'y a pas d'autres méthodes d'authentification, l'utilisateur restera donc inconnu.

  Couramment on souhaite utiliser user_autocreate = True pour cette méthode d'authentification. moin va alors automatiquement créer un profil utilisateur si l'utilisateur qui vient de s'identifier n'en possède déjà pas un. Ainsi l'utilisateur n'a pas besoin de le créer lui-même.

php_auth

Pour activer l'intégration de Single-Sign-On avec les applications PHP, utilisez ce module. Il lit les fichiers de session PHP et à partir de là s'intègre directement avec les systèmes d'authentification PHP.

Pour utiliser ce module, ajoutez les lignes suivantes dans le code votre configuration :

   1     from MoinMoin.auth import php_auth
   2     auth = [php_auth()]

php_auth : comporte les paramètres suivants :

   1 php_auth(apps=['egw'], s_path="/tmp", s_prefix="sess_")

• apps est la listes des applications autorisées

• s_path est le chemin d'accès des fichiers de session PHP

• s_prefix est le préfixe des fichiers de session PHP

Actuellement l'unique application PHP supportée est eGroupware 1.2. Mais il devrait être relativement facile d'ajouter quelques lignes de codes pour extraires les informations nécessaires de la session PHP.

Combiner de multiples méthodes d'authentification

Pour combiner par exemple l'authentification http et les cookies, votre wikiconfig.py pourrait contenir :

   1     from MoinMoin.auth import http, moin_cookie
   2     auth = [http, moin_cookie]

Dans cet exemple, moin va d'abord vérifier que l'authentification http renvoie un utilisateur valide. Si c'est le cas, il n'utilisera que cela. Sinon et si la valeur continue_flag retourné par la méthode d'authentification http est égale à True, il continuera à vérifier les autres méthodes d'authentification de la liste - moin_cookie dans notre cas... ( doit être mis à jour )

• Naturellement toutes les combinaisons ne sont pas sensées.

Créez votre propre méthode d'authentification

Voir la partie commentée des fichiers de configuration dans contrib/auth_externalcookie/ et MoinMoin/auth.py dans l'archive distribuée de moin pour obtenir des exemples de mise en place d'une authentification.

Voici un court résumé de ce qui est actuellement possible :

• utiliser le formulaire de connexion PréférencesUtilisateur comme votre propre interface utilisateur pour votre méthode d'obtention des noms et mots de passe

• rechercher parmi les profils utilisateurs existant un utilisateur correspondant (la correspondance peut se faire au niveau du nom, de l'adresse email, ou de quelque chose que vous auriez pu mettre dans pseudonyme)

• créer un objet utilisateur et le laisser enregistrer quels attributs doivent être déterminés par la méthode d'authentification (et par conséquent ne doivent pas être disponible sur PréférencesUtilisateur)

• mettre à jour les valeurs du profil utilisateur à partir de données externes
• créer automatiquement des profils utilisateurs