Table des matières

Signature mail avec DKIM pour ses (sous)domaines

Signature mail avec DKIM pour ses (sous)domaines

DKIM (DomainKeys Identified Mail) ajoute une signature aux mails sortants de vos serveurs mail, et permet ainsi aux serveurs destinataires de vérifier cette signature. Pour ce faire il lui suffit d'interroger votre DNS ou vous devez stocker votre clef publique.

On va voir ici comment mettre en place DKIM pour un ensemble de domaines/sous domaines et un ensemble de serveurs mails. Tous les serveurs sont sous debian stable (wheezy) mais ces procédures sont transposables facilement sur votre distrib.

Prérequis

au moins un domaine DNS dont vous souhaitez signer les mails
au moins un serveur de mail configuré pour envoyer les mail de ce(s) domaine(s)

Installation des dépendances :

# apt-get install opendkim opendkim-tools

opendkim-tools sert par exemple pour générer les clefs, il n'est pas forcément nécessaire sur tous vos serveurs

Configuration de DKIM

On commence par créer le répertoire qui contiendra notre configuration :
```
# mkdir /etc/opendkim
```

Adapter le configuration du démon opendkim à nos besoins, pour cela éditer le fichier /etc/opendkim.conf et ajouter/remplacer :

# LogWhy est utile en phase de debug/tests, période où le mettre à yes est utile.
# Idem pour X-Header qui sert juste à savoir si on est bien passé dans opendkim.
LogWhy           Yes
SyslogSuccess    yes
X-Header         yes

# on remplacera ces valeurs par les suivantes une fois la mise en place validée :
#LogWhy           no
#SyslogSuccess    no
#X-Header         no

# Methode(s) a utiliser pour signer les messages (simple ou relaxed) : par defaut simple
# on peut mettre 2 valeurs séparées par un / auquel cas la premiere sera utilisee pour l'entete et la seconde pour le corps du mail
Canonicalization        relaxed/simple

# Integration postfix/dkim : on se souvient que sous debian/ubuntu postfix tourne en environnement chroot :
Socket                  local:/var/spool/postfix/var/run/opendkim/opendkim.sock
UserID                  opendkim:opendkim

# Et enfin le lien vers la configuration de nos domaines et notre infra :
ExternalIgnoreList      refile:/etc/opendkim/TrustedHosts
InternalHosts           refile:/etc/opendkim/TrustedHosts
KeyTable                refile:/etc/opendkim/KeyTable
SigningTable            refile:/etc/opendkim/SigningTable

Génération de nos clefs

On commence par créer un répertoire pour chaque domaine/sous domaine utilisé, comme par exemple pour domaine1.com et sous.domaine2.net :
```
# mkdir -p /etc/opendkim/keys/domaine1.com/
# mkdir -p /etc/opendkim/keys/domaine2.net/sous/
```

Concernant la génération de clefs je suggère de choisir pour le selector une forme type SERVEUR-DATE où SERVEUR est le nom du serveur utilisant la clef et DATE est la date format US (YYYYMMDD) de génération de la clef : cela permet d'ajouter facilement de nouvelles clefs, de nouveaux serveurs et de publier tout ça dans nos DNS sans risquer de problèmes avec les différents niveaux de cache (certains client peuvent continuer à demander une ancienne clef le temps de la propagation DNS).

Les requetes DNS associées seront donc selector._domainkey.example.com“

Génération des clefs : par défaut une clef de 1024 bits sera générée, sinon on peut spécifier la longueur avec l'option -b, comme par exemple -b 2048. On spécifie le selector comme mentionné ci dessus, et le domaine avec -d ce qui nous donne :
```
# opendkim-genkey -b 2048 -D /etc/opendkim/keys/domaine1.com/ -s mx1-20150403 -d domaine1.com
# opendkim-genkey -D /etc/opendkim/keys/domaine2.net/sous/ -s mx1-20150402 -d sous.domaine2.net
```

Dans ce cas les selector sont donc mx1-20150403 pour domaine1.com et mx1-20150402 pour sous.domaine2.net. Ces commandes génèrent chacun 2 fichiers : un fichier selector.private et selector.txt contenant respectivement la clef privée et la clef publique qu'il faudra ensuite ajouter à la configuration DNS de votre domaine.

Intégration postfix-opendkim

Donner le droit a l'utilisateur faisant tourner le démon opendkim de lire ces clefs :

# chgrp opendkim /etc/opendkim/keys/domaine1.com/*
# chmod g+r /etc/opendkim/keys/domaine1.com/*
# chgrp opendkim /etc/opendkim/keys/domaine2.net/sous/*
# chmod g+r /etc/opendkim/keys/domaine2.net/sous/*

Restreindre l'acces aux clefs privées (sinon de toutes facons opendkim ne marchera pas :p ) :

# chown opendkim:opendkim /etc/opendkim/keys/domaine1.com/*private
# chmod 400 /etc/opendkim/keys/domaine1.com/*private
# chown opendkim:opendkim /etc/opendkim/keys/domaine2.net/sous/*private
# chmod 400 /etc/opendkim/keys/domaine2.net/sous/*private

Dans le cas ou votre postfix tourne dans un chroot (debian/ubuntu/..), il faut créer le répertoire qui contiendra le socket de communication entre postfix et dkim :
```
# mkdir -p /var/spool/postfix/var/run/opendkim/
# chgrp opendkim /var/spool/postfix/var/run/opendkim/
# chmod g+w /var/spool/postfix/var/run/opendkim/
```
puis ajouter l'utilisateur postfix au groupe opendkim :
```
# adduser postfix opendkim
```

Ajouter les clefs publiques aux zones DNS

Il faut ajouter le contenu du fichier selector.txt a la bonne zone DNS. Pour se faire si vous utilisez bind et qu'il tourne sur la même machine (fichiers de zone /etc/bind/domaine :

# cat /etc/opendkim/keys/domaine1.com/mx1-20150403.txt >> /etc/bind/domaine1.com

Pour un sous domaine, il faut légèrement modifier le contenu du fichier .txt en l'ajoutant : SERVEUR-DATE._domainkey devient SERVEUR-DATE._domainkey.sousdomaine, donc dans notre exemple de sous.domaine2.net : “mx1-20150402._domainkey.sous”

Dans le cas ou vous avez utilisé une longueur de clef supérieur a 1024, cette ligne dépassera 255 caractères, ce qu'on ne peut faire : il faut donc découper cette ligne en plusieurs, cf http://razzed.com/2009/03/05/dkim-txt-records-in-dns-exceeding-255-characters/ : notre ajout sera de la forme :

mx1-20150403._domainkey IN TXT ( "v=DKIM1; k=rsa; p=LeDebutde MaClefPubliqueQuiEstTellementLongueQuIlFautEnFaitLaSeparer............................................................"
"EtLaMettreSurUneDeuxiemeLigne..................................................
"VoireMemeUneTroisiemeVuQuOnEstDesOUFS" )

Il va sans dire que chacune des lignes ainsi obtenues doit faire moins de 255 caractères.

Une fois ces modifications intégrées dans vos zones, il faudra comme d'habitude incrémenter le numéro de série de vos zones et les recharger : rndc reload peut vous aider

Paramétrage de nos domaines dans DKIM

Créer le fichier /etc/opendkim/TrustedHosts pour y ajouter les noms DNS et adresses IP à qui vous faites confiance pour envoyer des mails sans authentification, dans notre cas uniquement la machine locale :
```
# cat << EOF > /etc/opendkim/TrustedHosts
127.0.0.1
localhost
::1

EOF
```

Ne pas oublier que seuls les mails provenant des noms DNS/adresses IPs contenues dans ce fichier seront effectivement signés (sans authentification préalable) : il peut donc êre utile de faire coïncider le contenu de ce fichier avec le mynetworks de votre postfix

Créer le fichier /etc/opendkim/KeyTable avec le contenu suivant : (adaptez les selector et le chemin des fichiers de clefs)

key.for.domaine1.com domaine1.com:mx1-20150403:/etc/opendkim/keys/domaine1.com/mx1-20150403.private
key.for.sous.domaine2.net sous.domaine2.net:mx1-20150402:/etc/opendkim/keys/domaine2.net/sous/mx1-20150402.private

L'utilisateur averti aura remarqué que chaque ligne est de la forme :

nom_donne_a_la_clef domaine:selector:/chemin/complet/vers/clef.private

Enfin créer le fichier de concordance domaines/clefs /etc/opendkim/SigningTable reprenant les noms ci dessus :
```
*@domaine1.com key.for.domaine1.com
*@sous.domaine2.net key.for.sous.domaine2.net
```

Il ne reste plus qu'a redémarrer opendkim :
```
# service opendkim restart
```
On peut vérifier que le socket a bien été créé :
```
ls -l /var/spool/postfix/var/run/opendkim/
```

Paramétrage postfix pour utiliser DKIM

Attendre un moment le temps de la propagation DNS
Dans le doute attendre encore un moment de plus
Verifier au niveau de vos DNS que vos zones distribuent maintenant vos clefs publiques (sur votre DNS principal mais aussi les secondaires) :

$ dig +short -t TXT mx1-20150403._domainkey.domaine1.com @::1

$ dig +short -t TXT mx1-20150402._domainkey.sous.domaine2.net

Si tout va bien attendre encore un peu

Ajouter dans le fichier /etc/postfix/main.cf :

# dire a postfix de ne pas jeter le mail meme en cas d'erreur de milter
milter_default_action = accept

# dire a postfix de parler a opendkim en utilisant son socket (relatif au chroot s'il y a)
smtpd_milters = unix:/var/run/opendkim/opendkim.sock
non_smtpd_milters = unix:/var/run/opendkim/opendkim.sock

Les lignes milters ci dessus sont valables si vous n'aviez pas déja de milter défini : si c'était le cas il suffit de les chaîner, comme par exemple :

smtpd_milters = unix:/spamass/spamass.sock, unix:/var/run/opendkim/opendkim.sock
non_smtpd_milters = unix:/spamass/spamass.sock, unix:/var/run/opendkim/opendkim.sock

Il ne reste plus qu'a redémarrer postfix

Si vous utilisez amavis quelques options sont à avoir absolument sans quoi vous allez passer deux fois dans opendkim : Dans le process de reinjection (en general 127.0.0.1:10025) dans le fichier /etc/postfix/master.cf :

s'assurer que l'option receive_override_options contient bien no_milters
s'assurer que l'option smtpd_milters est presente avec une valeur vide

Tout ceci nous donne quelque chose comme :

127.0.0.1:10025 inet n    -       n       -       -     smtpd
     -o content_filter=
...
     -o receive_override_options=...,...,...,no_milters
...
     -o smtpd_milters=
...

Vérification du fonctionnement

Pour vérifier le fonctionnement :

cherchez les logs d'opendkim dans vos logs de serveur mail
vérifiez dans les en-têtes de vos mails sortant qu'ils contiennent bien les infos DKIM
L'extension DKIM verifier pour thunderbird peut vous servir

Et bien sur une fois que tout fonctionne pensez à diminuer les logs opendkim (voir plus haut)

Aller plus loin

Vous voudrez peut être jeter un coup d’œil a cette page sur l'utilisation de mailman avec DKIM

Références

https://www.tty1.net/blog/2014/dkim-with-postfix_en.html