Monthly Archive for September, 2009

Client Windows XP, KFW, KDC Unix et Mozilla

Un petit post pour mémoire sur le fonctionnement d’un client Windows XP avec KFW (Kerberos For Windows) et les outils Mozilla. Mon but est de proposer une authentification Kerberos aux utilisateurs itinérants : non raccordés à un domaine, compte local à la machine et authentification (au moment du login) non liée au KDC. KFW est un utilitaire distribué par le MIT qui permet d’intégrer une couche GSSAPI “traditionnelle” dans Windows. En effet, Windows utilise une variante fermée de la GSSAPI qui se nomme SSPI (Security Support Provider Interface). L’installation de KFW n’est pas compliquée (suivant, suivant et terminer). Une fois installée, on doit configurer le fichier krb5.ini (qui ressemble comme deux goutes d’eau au krb5.conf). Voici un exemple minimal :

[libdefaults]
	default_realm = MONDOMAINE.FR
 
[realms]
        MONDOMAINE.FR = {
                kdc = kdc.mondomaine.fr
        }
 
[domain_realm]
	.monrealm.fr = MONDOMAINE.FR
	mondomaine.fr = MONDOMAINE.FR

Ensuite, il suffit de cliquer pour obtenir les credentials (TGT). Ensuite, pour les applications Mozilla il faut faire un petit réglage. En effet, Firefox et Thunderbird utilisent par défaut la SSPI. On peut forcer l’utilisation de la GSSAPI en désactivant le SSPI. Pour ce faire, dans “Outils”, “Options” et “Editeur de configuration” placez le network.auth.use-sspi à false.

Extrusion Detection : Security Monitoring for Internal Intrusions

taoextrusionHier soir j’ai terminé le livre “Extrusion Detection : Security Monitoring for Internal Intrusions” de Richard Bejtlich. Ce livre est dédié à l’étude du phénomène d’extrusion. L’extrusion est un acte malveillant initié depuis le réseau interne. Cet acte peut avoir comme résultat la fuite d’information. Il peut aussi être la conséquence de compromissions de vos machines. Une fois sous le contrôle d’un pirates, vos machines peuvent se mettre à initier des attaques vers d’autres sites. Sur une dizaine de chapitres, l’auteur propose des méthodes basées sur l’analyse du trafic réseau pour mettre ces malveillances en lumières. Les aspects techniques sont largement couverts : l’instrumentation du réseau (sondes, boitiers TAP etc.), la collecte des éléments réseau (statistiques globales, données de sessions et stockage des payloads), leur analyse (le plus souvent via des outils libres : sguil, argus, snort etc.). De bonnes astuces sont également livrées, telles que le “sink hole” qui consiste à introduire des routes plus larges que celles réellement utilisées afin de capturer le trafic illégitime. Ce livre est à mon sens excellent dans la mesure ou il donne des pistes exploitables pour garder un oeuil sur l’activité de son réseau et surtout de pouvoir présenter des éléments en cas de compromission. L’auteur propose également un livre entièrement dédié à l’analyse du trafic réseau dans un optique plus classique de détection d’intrusion. Il est déjà sur ma table de nuit …

Postfix et Kerberos howto

Après moult jours de tripatouillage, je suis parvenu à faire fonctionner l’authentification Kerberos avec Postfix. En effet, on trouve dans les howtos un nombre impressionnant de façon d’y arriver (avec comme toujours certaines configurations dont on peut se demander comment elles fonctionnent). Installons d’abord les paquets :

$ apt-get install postfix
$ apt-get install libsasl2-modules-gssapi-mit

Le daemon saslauthd est inutile. Passons maintenant à l’enregistrement du service SMTP dans le KDC en créeant un ticket pour le service (smtp/fqdn).

$ kadmin.local
kadmin: addprinc -randkey smtp/mailtest.mondomaine
kadmin: ktadd -k /etc/smtp.keytab smtp/mailtest.mondomaine

Il faut ensuite recopier le /etc/smtp.keytab depuis le KDC vers le serveur de mail (mailtest). Sur mailtest ce fichier doit être installé dans le chroot de Postfix car par défaut le processus smtpd acceptant les connexions authentifiées pour l’envoi de messages est chrooté dans /var/spool/postfix. Tant que l’on est à parler du chroot, il faut aussi recopier le répertoire temporaire /var/tmp dans /var/spool/postfix/var car il est utilisé par le processus krb5.login. Il nous faut aussi le /etc/krb5.conf dans /var/spool/postfix/etc. Dernière note sur le chroot, on peut aller voir dans le script de démarrage (/etc/init.d/postfix) les fichiers copiés automatiquement dans le chroot au démarrage du service.

Une fois le chroot configuré, passons au master.cf pour activer un smtpd en SSL sur le port 465 :

smtps inet n - - - - smtpd
-o smtpd_tls_wrappermode=yes
-o smtpd_sasl_auth_enable=yes
-o smtpd_client_restrictions=permit_sasl_authenticated,reject
-o milter_macro_daemon_name=ORIGINATING

Occupons nous aussi du main.cf :

import_environment = KRB5_KTNAME=/etc/smtp.keytab
 
[...]
 
smtpd_sasl_auth_enable = yes
smtpd_sasl_type = cyrus
smtpd_sasl_security_options = noanonymous
broken_sasl_auth_clients = yes
 
smtpd_recipient_restrictions = permit_sasl_authenticated,
                                permit_mynetworks,
                                reject_unauth_destination

Le import_environment est super important car il permet de positionner l’emplacement d fichier keytab utilisé par le service smtp kerberisé. On redémarre un coup Postfix et on test les méthodes d’authentification présentées aux clients avec la classqiue commande “ehlo” :

$ openssl s_client -connect mailtest.univ-orleans.fr:465

Nous renvoie la sortie suivante :

220 mailtest.mondomaine ESMTP Postfix (Debian/GNU)
ehlo mailtest.mondomaine
250-mailtest.mondomaine
250-PIPELINING
250-SIZE 10240000
250-VRFY
250-ETRN
250-AUTH GSSAPI DIGEST-MD5 NTLM CRAM-MD5 PLAIN LOGIN
250-AUTH=GSSAPI DIGEST-MD5 NTLM CRAM-MD5 PLAIN LOGIN
250-ENHANCEDSTATUSCODES
250-8BITMIME
250 DSN

La GSSAPI est bien notre mécanisme d’authentification par défaut. Testons maintenant avec un Thunderbird. Pour le configurer, allez dans les propriétés du compte puis “serveur sortant smtp”. Ajoutez en un avec comme nom de serveur mailtest.mondomaine, port 465, selectionnez “Utiliser un nom d’utilisateur et un mot de passe” et enfin choisissez “Utiliser un connexion sécurisée SSL”. Vous devriez maintenant pouvoir envoyer tous vos messages authentifié via Kerberos. Sus au spam interne !

Le debugging est assez complexe, surtout avec le chroot de Postfix. Pour vous aider, vous pouvez utiliser à mort strace en l’attachant au processus “master” de Postfix en suivant tout les types de fork (option -fF) et en sélectionnant certains appels systèmes (-e).

Hé toi ! Oui toi la bas …

Sous FreeBSD, je cherchais comment utiliser le nom du jail à la place du JID dans la commande jexec. A priori d’après le man c’est possible :

     -n jailname
             The name of the jail, if given upon creation of the jail.  This
             is not the hostname of the jail.

Bingo, j’essaye :

jexec -n monjail '' ls

Ca pète le message d’erreur suivant :

jexec: Cannot identify jail.

je vérifie vingt fois le nom de mon jail et retente çamarchepas. Je décide donc de mater dans le man de jail (RTFM rulez) et je trouve ça :

     -n jailname  Assign and administrative name to the jail that can be used
                  for management or auditing purposes.  The system will not
                  enforce the name to be unique.

Une fois la ligne jail_monjail_flags=”-n monjail” ajoutée dans le rc.conf et le service jail relancé çamarchemieux.

Validation de la couche SASL

Une petite procédure pour valider le fonctionnement de la SASL (Simple Athentication and Security layer) avec le mécanisme d’authentification GSSAPI (Kerberos). Nous supposons qu’un KDC est disponible (et surtout fonctionne). Si ce n’est pas le cas, un bon howto est fourni par le projet Ubuntu. Tout d’abord, installons ce qu’il faut :

apt-get install sasl2-bin
apt-get install libsasl2-2
apt-get install libsasl2-modules-gssapi-mit

Cyrus-SASL dispose d’outils pour valider le bon fonctionnement de la SASL sur votre machine. Ce sont les outils sasl-sample-[client|server]. C’est la première étape à réussir pour utiliser la SASL avec des application externes. Pour le test, on doit disposer de deux terminaux sur la machine (un pour le client, un autre pour le serveur) sur lesquelles nous sommes authentifiés. Les manipulations sont a effectuer sur les deux terminaux. Commençons par la liste des tickets en cours de validité :

klist

Nous renvoie :

klist: No credentials cache found (ticket cache FILE:/tmp/krb5cc_0)
 
Kerberos 4 ticket cache: /tmp/tkt0

Demandons un ticket pour l’utilisateur toto :

kinit toto

Password for toto@REALM.FR:

Listons les tickets :

klist

Devrais renvoyer :

Ticket cache: FILE:/tmp/krb5cc_0
Default principal: toto@REALM.FR
 
Valid starting     Expires            Service principal
09/10/09 11:16:57  09/10/09 21:16:57  krbtgt/REALM.FR@REALM.FR
        renew until 09/11/09 11:13:49
 
Kerberos 4 ticket cache: /tmp/tkt0
klist: You have no tickets cached

Nous avons nos tickets, on peut tester la couche SASL. Sur le terminal dédié au serveur, nous allons utiliser le programme sasl-sample-server :

[root@term1]# sasl-sample-server -s host -p /usr/lib/sasl2 -m GSSAPI -d mybox.mydomain

Cette commande prend en argument un service (-s), l’emplacement des librairies des différents mécanismes supportés (-p), le mécanisme forcé (-m) et le FQDN de la machine (-d). Ici on utilise le service host (service de test), pour tester le mécanisme GSSAPI. Elle produit les résultats suivants :

Forcing use of mechanism GSSAPI
Sending list of 1 mechanism(s)
S: R1NTQVBJ
Waiting for client mechanism...

Sur la terminal dédié au client, on va lancer :

[root@term2]# sasl-sample-client -s host -p /usr/lib/sasl2 -m GSSAPI -n myhost.mydomain -u toto

Cette commande prend le nom d’utilisateur que l’on cherche à authentifier (-u). Ici il s’agit de “toto” qui est un principal de notre realm Kerberos. On doit avoir la sortie suivante :

service=host
Waiting for mechanism list from server...

Sur la sortie du serveur, on a la chaîne suivante : “S: R1NTQVBJ”. Il faut la passer au client dans la mesure où il n y a pas d’interaction réelle entre les deux programmes. Pour la passer, un simple copier coller suffit. Attention cependant, pour la valider il ne faut pas appuyer sur entrée mais faire [ctrl]+D (2 fois).Si on appuie sur entrée, cela concatène un retour charriot à la chaine non attendu par le programme. La réponse du client est :

S: R1NTQVBJrecieved 6 byte message
Forcing use of mechanism GSSAPI
Choosing best mechanism from: GSSAPI
returning OK: p10613
Using mechanism GSSAPI
Preparing initial.
Sending initial response...
C: R1NTQVBJAGCCAj8GCSqGSIb3EgECAgEAboICLjCCAiqgAwIBBaEDAgEOogcDBQAgAAAAo4IBPWGCATkwggE1oAMCAQWhERs
PVU5JVi1PUkxFQU5TLkZSoiwwKqADAgEDoSMwIRsEaG9zdBsZbWFpbHRlc3QxLnVuaXYtb3JsZWFucy5mcqOB7DCB6aADAgE
SoQMCAQOigdwEgdnWwLC9Ycz3AQxjwf/iNs9xldAuOErtfaNhCDqpq7tbV1FhzFjV+vv8HdbS9qD2eDwYvyglHSLgLJbsPZdl
wPvxllN/NuOVrJB
/8FosD1sWvt1FKIyXDwovOsIvKcFa8zibivG0HBRxEWQQULrC8Wlr1qFzvjWQMlAriZ2+uEKxWVqIGDbDk9bndAGhXmZdN
KfmqzzsBkqPEIAxAW4uTaIRNxHwonizG7MbngRZhuMBCki3L7+nAxxB6bWHhuZEvPA8VLBBa5lemkbr5+k1hRuiuxX1Q
muS3+TGpIHTMIHQoAMCARKigcgEgcU8+fSbMrZekojdtuhE+RPXgQHFRjufJpFZvI+F/csYU6cZE3hNFojp4yrTcYRptlLSTV
AcfBp50xjjoHicbm5Uzvwaq+6+aDdRomCfyiScuJ1ol+F36aNi2gdhjKuV6glWCXU1DM+HaV4DWwQBIRCIdHTwQC/czfz6
nWAz
o8x0cPkOkQwHmV
vWtBZwlaref8LGWfckQXK8QLNBVxBzwmeTuar4dZw+kA1sNjQeFUqvg5MixRAxTu1xjTdTyvlGK1PONAtnvw==
Waiting for server reply...

Copier coller de la réponse du client sur le serveur :

Sending response...
S: YIGZBgkqhkiG9xIBAgICAG+BiTCBhqADAgEFoQMCAQ+iejB4oAMCARKicQRvb+47IUZ7sugVxWME3mMwey4jj
s/cvWXv6X1bgy1ETeaL8FChCtUnIvalmjHzUR9dplYmU68sKyFkc7xKHvKIbhkRk5F7PMy10iN+pspGDrFsCClm3ub
xMArsS9EfqBOzWonMRFZVhdPPAL7bgRGY
Waiting for client reply...

On colle ça dans le client :

C:
Waiting for server reply...

La réponse est un caractère blanc que l’on colle sur le serveur :

C: got ''
Sending response...
S: BQQF/wAMAAAAAAAAG76J+wcACACTtO/4HK+L2u98azg=
Waiting for client reply...

On transmet au client :

S: BQQF/wAMAAAAAAAAG76J+wcACACTtO/4HK+L2u98azg=recieved 32 byte message
Sending response...
C: BQQE/wAMAAAAAAAAD8CVGwQACABwMTA2MTMJcB2SqMJGtwEtfAk=
Negotiation complete
Username: toto
SSF: 56
Waiting for encoded message...

Hop, on colle dans le serveur :

C: BQQE/wAMAAAAAAAAD8CVGwQACABwMTA2MTMJcB2SqMJGtwEtfAk=got ' '
Negotiation complete
Username: p10613
Realm: (NULL)
SSF: 56
sending encrypted message 'srv message 1'
S: AAAASgUEB/8AAAAAAAAAABu+ifwxS1DHVyL8o4X8J2HeKsv8SaZsa36ZCAp0znoCUh6V
Fjf0+cxdGXX6c9Xie6+3bf+QJ8/N4H0cxS25
Waiting for encrypted message...

Dernier envoi sur le client :

S: AAAASgUEB/8AAAAAAAAAABu+ifwxS1DHVyL8o4X8J2HeKsv8SaZsa36ZCAp0znoCUh6V
Fjf0+cxdGXX6c9Xie6+3bf+QJ8/N4H0cxS25recieved 78 byte message
recieved decoded message 'srv message 1'
sending encrypted message 'client message 1'
C: AAAATQUEBv8AAAAAAAAAAA/AlRxbCjz0s/JxqbqHFHFHQNlOit4+ylbVbsmcaEJ5
PDTa8F8A7NhQ9sdciXNOhDe1oGYrCiF5Y23CaZdYUEbF

On clôt le côté serveur également :

C: AAAATQUEBv8AAAAAAAAAAA/AlRxbCjz0s/JxqbqHFHFHQNlOit4+ylbVbsmca
EJ5PDTa8F8A7NhQ9sdciXNOhDe1oGYrCiF5Y23CaZdYUEbFgot ''
recieved decoded message 'client message 1'

Le petit soucis du [ctrl]+D m’a fait perdre un sacré temps. En tout cas, si vous arrivez jusque la c’est que vous avez simulé une authentification via la GSSAPI (et surtout que ça marche ;-) ).

Nouvelle bannière !

Merci à Catherine qui m’a fait une superbe bannière pour ce blog. Vu mon goût de chiottes en terme de couleur et de création graphique, sa contribution a été plus que précieuse ;-)

Merci encore Catherine ! :-)

Reconstruction de paquets deb

J’ai souhaité ajouter le support de Kerberos dans le package squid3 pour Debian lenny stable. Il est inclus dans la squeeze mais pas dans la stable. J’ai essayé de faire ça à la mode “quick but not so dirty” c’est à dire en créant un paquet .deb personnalisé.

1) Téléchargement des dépendance de construction pour le paquet squid3 :
apt-get build-dep squid3

2) Téléchargement des paquets de développement additionnels (libraires de développement Kerberos) :
apt-get install libgssglue-dev comerr-dev libkrb5-dev

3) Téléchargement des sources du paquet Debian :
apt-get source squid3

4) Création du paquet :
cd squid3-3.0.STABLE8
On va bricoler le debian/rules pour ajouter le support de l’authentification Kerberos dans les schémas d’authentification Postfix.

--enable-auth=basic,digest,ntlm,negotiate
--enable-negotiate-auth-helpers=squid_kerb_auth

On recompile ensuite les sources qui vont produire deux paquets : squid3 et squid3-common.
dpkg-buildpackage -b

5) Installation du paquet :
cd ..
dpkg -i squid3-common_3.0.STABLE8-3+lenny2_all.deb
dpkg -i squid3_3.0.STABLES8-3+lenny2_i386.deb

Voila, c’est un peu gruik mais pas trop.

Authentification Dovecot sous Postfix

Suite de l’histoire de Dovecot. Je reçois mes mails sur ma kimsufi. Je suis un homme un peu plus heureux. Le bonheur serait un peu plus complet si je pouvais émettre des mails de n’importe où grâce à un relai authentifié et chiffré. J’ai trouvé un début de solution sur le wiki de Dovecot mais il a fallu quand même d’autres étapes pour que ça marche. Tout d’abord, installation de Postfix (toujours sous FreeBi) avec les options de compilation suivantes :

# This file is auto-generated by 'make config'.
# No user-servicable parts inside!
# Options for postfix-2.6.3,1
_OPTIONS_READ=postfix-2.6.3,1
WITH_PCRE=true
WITH_SASL2=true
WITH_DOVECOT=true
WITHOUT_SASLKRB=true
WITHOUT_SASLKRB5=true
WITHOUT_SASLKMIT=true
WITH_TLS=true
WITHOUT_BDB=true
WITHOUT_MYSQL=true
WITHOUT_PGSQL=true
WITHOUT_OPENLDAP=true
WITHOUT_CDB=true
WITHOUT_NIS=true
WITHOUT_VDA=true
WITHOUT_TEST=true

Une fois cette installation effectuée, un petit coup de postfix_enable=”YES” dans le rc.conf et ça démarre. Attention quand même, il faut bien penser à désactiver Sendmail :

sendmail_enable="NO"
sendmail_submit_enable="NO"
sendmail_outbound_enable="NO"
sendmail_msp_queue_enable="NO"
 
postfix_enable="YES"

Je souhaite une configuration en “full” SSL (c’est à dire pas de START_TLS) sur le port 445 avec authentification. Pour avoir une instance chiffrée de Postfix sur le port 445, il faut ajouter ce service dans le main.cf.

smtps     inet  n       -       n       -       -       smtpd
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_client_restrictions=permit_sasl_authenticated,
                           permit_my_networks,
                           reject_unauth_destination

Le paramètres “smtpd_tls_wrappermode=yes” lie l’instance de smtpd invoquée au port 445 et surtout active le SSL (en mode enforcé). Si on veut forcer à tout prix le chiffrement SSL même sur le port 25 (par exemple depuis un réseau interne), il faut regarder du côté de la variable “smtpd_tls_security_level” qui propose trois niveaux : none (pas de chiffrement), may (si le client veut, on chiffre) et encrypt (quoiqu’il arrive, on chiffre). Le paramètre “smtpd_sasl_auth_enable=yes” active une authentification via la SASL (par défaut Postfix ne le fait pas). Cette primitive permet surtout de profiter de la cible “permit_sasl_authenticated” pour relayer les clients dument authentifiés. Au niveau de la configuration de Postfix, tout le reste se passe dans le main.cf. Il faut commencer par lui indiquer où trouver les certificats :

smtpd_tls_key_file = /usr/local/etc/ssl/smtps/server.key
smtpd_tls_cert_file = /usr/local/etc/ssl/smtps/server.crt

Ensuite on lui fixe quelques variables nécessaires au bon fonctionnement du service de messagerie :

mynetworks_style = host
myhostname = silky.garnett.fr
mydomain = garnett.fr 
mydestination = $myhostname, localhost.$mydomain, localhost, $mydomain
unknown_local_recipient_reject_code = 550
mynetworks_style = host
mynetworks = 127.0.0.0/8
relayhost = [fqdn.demon.relai]

On notera juste que je fais relayer mon courrier par la machine fqdn.demon.relai, mon MTA n’est donc pas en frontal du net pour l’envoi de messages SMTP. Je ne connaissais pas non plus le “mynetworks_style = host” qui est bien pratique pour du vite fait bien fait. On doit ensuite activer la SASL de Dovecot :

smtpd_sasl_type = dovecot
smtpd_sasl_path = /var/spool/postfix/private/auth
smtpd_sasl_auth_enable = yes
smtpd_sasl_local_domain = $myhostname
smtpd_sasl_security_options = noanonymous
broken_sasl_auth_clients = yes
smtpd_recipient_restrictions = permit_sasl_authenticated,
                             permit_mynetworks,
                             reject_unauth_destination

Le paramètre “smtpd_sasl_type” donne le nom de la couche SASL à utiliser (ici dovecot, évidemment ;-) ). Le “smtpd_sasl_path” donne le chemin du fichier qui va permettre à Dovecot et Postfix de parler ensemble. Ce fichier doit absolument n’être utilisable que par l’utilisateur système postfix :

srw-rw----  1 postfix  postfix  0 Sep  2 08:19 /var/spool/postfix/private/auth

Pour éviter les connexions anonymes, il faut positionner “smtpd_sasl_security_options = noanonymous”. Enfin “broken_sasl_auth_clients = yes” permet de supporter les MUA de merde comme Outlook. Côté Postfix, on est paré ! Passons à Dovecot.

Pour Dovecot, la seule chose à faire est de préparer le socket de discussion entre Dovecot et Postfix (pour l’authentification). Dans le dovecot.conf :

socket listen {
    master {
      path = /var/run/dovecot/auth-master
      mode = 0600
    }
    client {
      path = /var/spool/postfix/private/auth
      mode = 0660
      user = postfix
      group = postfix
    }
}

Redémarrage de Dovecot et Postfix et il n y a plus qu’a dérouler ! Pour debugguer, un petit telnet en local sur le port 25 de votre machine devrait vous renvoyer les informations suivante (après avoir été poli et fait le ehlo) :

Trying 192.168.0.1...
Connected to silky.
Escape character is '^]'.
220 silky.garnett.fr ESMTP Postfix
ehlo silky.garnett.fr
250-silky.garnett.fr
250-PIPELINING
250-SIZE 10240000
250-VRFY
250-ETRN
250-STARTTLS
250-AUTH CRAM-MD5
250-AUTH=CRAM-MD5
250-ENHANCEDSTATUSCODES
250-8BITMIME
250 DSN

Voila, on notera que Postfix supporte bien évidemment la SASL standard et que donc toutes les fantaisies sont permises (par exemple avec Kerberos … en SSO … MMmmm … mon caleçon en est tout taché !). Bon courage and may the force be with you :-) !

Sécurité de Dovecot

Dans un cadre professionnel, j’ai du examiner les principaux mécanismes de sécurité de Dovecot. Dovecot est à la base un serveur IMAP (même si il propose un module POP3). Les variantes sécurisées IMAPS et POPS sont évidemment supportées. Elles intègrent le support de SSL pour authentifier le serveur auprès des clients et chiffrer la connexion. En effet, les protocoles de messagerie ont tendance à se reposer sur des authentification en clair. Commençons par installer Dovecot. J’ai décidé de faire ma configuration sur FreeBSD. L’installation est faite via les ports. Mes options de compilation sont les suivantes :

# This file is auto-generated by 'make config'.
# No user-servicable parts inside!
# Options for dovecot-1.2.3
_OPTIONS_READ=dovecot-1.2.3
WITH_KQUEUE=true
WITH_SSL=true
WITHOUT_IPV6=true
WITHOUT_POP3=true
WITH_LDA=true
WITHOUT_MANAGESIEVE=true
WITHOUT_GSSAPI=true
WITHOUT_VPOPMAIL=true
WITHOUT_BDB=true
WITHOUT_LDAP=true
WITHOUT_PGSQL=true
WITHOUT_MYSQL=true
WITHOUT_SQLITE=true

Comme d’habitude, il convient d’ajouter dovecot_enable=”YES” dans le rc.conf. L’essentiel de la configuration se fait dans le fichier dovecot.conf. Pour activer IMAPS :

protocols = imaps

Notre configuration va prendre un certificat autosigné côté serveur.

openssl req -x509 -nodes -days 3650 -newkey rsa:2048 -out ./server.crt -keyout ./server.key

Cette commande génère une clé RSA de 2048 bits “server.key” et le certificat autosigné associé “server.crt”. Pour les déclarer dans Dovecot, il faut utiliser les primitives suivantes :

ssl_cert_file = /usr/local/etc/ssl/dovecot/server.crt
ssl_key_file = /usr/local/etc/ssl/dovecot/server.key

J’ai pour habitude des les placer dans /usr/local/etc/ssl/dovecot. Au niveau ACL du système de fichier, je retire les droits d’écriture sur la clé et le certificat pour tout le monde (user, group et other). Pour la clé, seul le propriétaire a le droit de lecture :

total 8
drwxr-xr-x  2 root  wheel   512 Aug 30 16:08 .
drwxr-xr-x  4 root  wheel   512 Aug 30 16:08 ..
-r--r--r--  1 root  wheel  1627 Aug 30 16:08 server.crt
-r--------  1 root  wheel  1675 Aug 30 16:08 server.key

Un aspect intéressant de Dovecot est qu’il utilise intensivement les principes de séparation et du moindre privilège. La séparation de privilèges implique un éclatement des processus pour idéalement tendre vers l’état suivant : 1 action = 1 processus système. Le moindre privilège implique que les droits du compte associé à chaque processus sont limités au strict minimum. En effet, une fois Dovecot démarré (et configuré) un seul processus tourne sous “root” :

root        61934  0.0  0.1  5652  1348  ??  SsJ  10:15PM   0:00.05 dovecot

Ce processus maitre sert uniquement à gérer les sockets réseaux liées à des ports priviligiés (ici imaps sur le 993) et à lancer le processus gérant l’authentification “dovecot-auth” ainsi que celui gérant le service IMAP jusqu’à ce que l’utilisateur s’authentifie “imap-login”. Le processus “imap-login” doit tourner sous un compte non privilégié (ici dovecot).

login_user = dovecot

Pour le processus “dovecot-auth” c’est moins clair. Dans notre configuration (détaillée par la suite) il n’est pas nécessaire d’utiliser le compte root. Un compte authdovecot a donc été crée.

authdovecot 62210  0.0  0.2  7828  1516  ??  SJ   10:48PM   0:00.01 dovecot-auth
authdovecot 62211  0.0  0.1  7828  1432  ??  SJ   10:48PM   0:00.00 dovecot-auth -w
dovecot     62212  0.0  0.3  9600  2584  ??  SJ   10:48PM   0:00.01 imap-login
dovecot     62213  0.0  0.3  9600  2584  ??  SJ   10:48PM   0:00.01 imap-login
dovecot     62214  0.0  0.3  9600  2584  ??  SJ   10:48PM   0:00.01 imap-login

Enfin le processus “imap” va gérer la session IMAP après connexion de l’utilisateur. Ce processus peut tourner sous deux identités :

  • Avec le compte système de l’utilisateur si celui-ci existe (notre cas).
  • Avec un compte générique pour toutes les boites (le plus souvent nommé vmail) dans le cas de destinataires virtuels. Ces destinataires n’ont pas d’existence au sens système du terme c’est à dire pas d’UID (on peut vivre sans UID ?).

Dans notre configuration, un utilisateur “nico” dédié au mail existe et son compte est bloqué. De cette manière, l’utilisateur dispose d’un UID et dovecot peut invoquer “imap” sous cette identité:

nico        69094  0.0  0.2  7708  2080  ??  SJ    7:20AM   0:00.01 imap [nico 193.XXX.XXX.XXX]

Pour dovecot, deux éléments composent un utilisateur : ses informations (login, uid etc.) et sa méthode d’authentification. Cette configuration se fait dans la section “auth default” du fichier dovecot.conf :

auth default {
  mechanisms = cram-md5 
  passdb passwd-file {
    args = /usr/local/etc/cram-md5.pwd
  }
  userdb passwd {
    args = blocking=yes
  }
  user = authdovecot
}

Le paramètre userdb donne la base des données des utilisateurs à utiliser. Par défaut Dovecot prend les comptes systèmes locaux (du moins ceux présentés par le service NSS où équivalent). Par exemple : si on a un annuaire LDAP avec des utilisateurs au format PosixAccount, on peut toujours utiliser la userdb par défaut (si NSS est bien configuré pour, of course !). La passdb contient les mots de passes chiffrés pour les utilisateurs. Par défaut, dovecot repose sur la PAM. Cette méthode possède un défaut majeur : le mot de passe circule en clair. Même avec le support de SSL, un man in the middle sauvage peut survenir (surtout sur un réseau local). La seule trace pour l’utilisateur sera la présentation d’un certificat invalide qu’il s’empressera d’accepter. Pour mitiger ce risque, il suffit de changer le mécanisme d’authentification (ici CRAM-MD5) :

mechanisms = cram-md5

Une fois cette modification effectuée, il faut se définir un fichier de mot de passe personnalisé. Dans notre exemple /usr/local/etc/cram-md5.pwd :

passdb passwd-file {
    args = /usr/local/etc/cram-md5.pwd
}

Les entrées de ce fichier sont au format ‘user:{algorithme}secret’. User correspond au nom d’utilisateur, algorithme renseigne sur la fonction de chiffrement appliquée et secret représente le mot de passe chiffré.

nico:{CRAM-MD5}**********

Cette configuration permet de limiter les droits de l’identité sous laquelle le processus “dovecot-auth” s’exécute. Deux point sont à prendre en compte : l’accès aux information utilisateur et l’authentification. Par défaut les utilisateurs ont le droit de récupérer la liste des comptes utilisateurs d’une machine (commande ‘getent passwd’). Coté authentification, La seule contrainte est que le compte système utilisé pour le processus ait accès en lecture sur le fichier pour faire les lookups.

-r--r-----   1 authdovecot  dovecot     80 Aug 31 19:45 cram-md5.pwd

Voila c’est fini ! Dans le prochain post, nous verrons comment s’appuyer sur l’authentification CRAM-MD5 de dovecot pour réaliser un service SMTP émetteur authentifié avec postfix.