Note du traducteur : ce chapitre ne fait pas partie du guide de Christophe Haas mais propose une alternative à son installation de dkim-filter qui ne fait plus partie des dépôts Debian Wheezy. Le paquet opendkim s'intègre parfaitemenent avec Postfix pour réaliser le contrôle DKIM sur l'envoi de mails et sur la réception. 

OpenDkim

Le projet OpenDkim est parti d'un fork du milter (contraction de l'anglais mail filter, filtre de mail) libre dkim-filter dans sa version 2.8.3. Il propose une implémentation libre du système d'authentification de mail DKIM (Domain Keys Identified Mail). Le projet comporte à la fois une bibliothèque C utilisable via une API dans divers programmes, et un milter permettant son utilisation avec des logiciels comprenant le protocole milter (comme Sendmail, Postfix etc.).  Son utilisation reste proche de celle du filtre dkim-filter.

Installation d'opendkim

On installe le paquet opendkim et le paquet opendkim-tools qui contient entre autre opendkim-genkey dont on aura besoin (openssl doit être installé).

apt-get install opendkim  opendkim-tools

Le service opendkim appartient à l'utilisateur opendkim et au groupe opendkim qui sont créés à l'installation et auxquels il faudra donner l'arborescence des fichiers de signature.

Configuration d'opendkim

Configurer opendkim pour la réception de mails

La configuration pour filtrer les mails en réception est très simple. Comme pour dkim-filter, du fait que Postfix tourne dans une prison chroot et ne peut accéder au sockets unix dans /var/run, nous allons communiquer avec lui via un service TCP. opendkim écoute sur le port 8891. On édite donc le fichier /etc/default/opendkim pour y ajouter la ligne :

SOCKET="inet:8891:localhost"

Puis on redémarre opendkim :

# /etc/init.d/opendkim restart
Restarting OpenDKIM: opendkim.

Maintenant opendkim écoute sur le port TCP 8891 sur l'interface localhost. Pour que Postfix puisse utiliser ce milter lancez ces commandes pour ajouter la bonne définition du milter à votre fichier /etc/postfix/main.cf :

postconf -e smtpd_milters=inet:127.0.0.1:8891
postconf -e non_smtpd_milters=inet:127.0.0.1:8891

Après cela Postfix va faire passer tous les mails (à la fois entrants et sortants) à travers votre filtre DKIM et vérifier les signatures DKIM (si il en trouve) des mails entrants. Il ne signe pas encore les mails sortants, cet aspect est traité dans le chapitre suivant.

A noter : vous pouvez décider de ce qui doit se passer si il y a un problème avec le filtre DKIM. Par défaut Postfix rejetera temporairement le mail jusqu'à ce que vous corrigiez le problème. C'est à vous de voir. Mais pour ma part je préfère simplement accepter le mail si il y a un problème avec le milter. Du coup j'ajoute :

postconf -e milter_default_action=accept

Configurer OpenDkim pour l'envoi de mails

Comme le précise Christoph Haas, l'idée principale de DKIM est de faire en sorte qu'un serveur de courrier signe automatiquement les mails sortants pour un domaine. Pour cela vous devez tout d'abord avoir une paire de clés cryptographiques. Heureusement vous n'avez pas besoin d'acheter un certificat car la publication de votre clé publique dans le DNS est suffisante. L'outil dont vous avez besoin est opendkim-genkey qui n'a besoin que du nombre d'octets que doit avoir la clé et du nom de domaine. Vous pouvez optionnellement utiliser un sélecteur pour utiliser plusieurs clés. Par défaut le sélecteur est nommé default. Je vous suggère d'utiliser votre nom de domaine comme sélecteur ce qui nommera vos clés correctement de façon automatique.

Certains des dossiers nécessaires à la configuration d'opendkim pour la signature des mails sortants ne sont pas créés à l'installation du paquet Debian. Seuls existent /et/default/opendkim que nous venons de modifier et /etc/opendkim.conf, l'arborescence contenant les clés de signature est à créer.

Arborescence des fichiers de configuration d'OpenDkim

L'arborescence des fichiers d'opendkim que nous allons utiliser est la suivante :

/etc/default/opendkim
/etc/opendkim.conf
/etc/opendkim.d
├── keys
│   ├── domain1
│   │   ├── 1024
│   │   │   ├── domain1.private
│   │   │   └── domain1.txt
│   │   ├── 4096
│   │   ├── domain1.private
│   │   └── domain1.txt
│   ├── domain2
│   │   ├── 1024
│   │   │   ├── domain2.private
│   │   │   └── domain2.txt
│   │   ├── 4096
│   │   ├── domain2.private
│   │   └── domain2.txt
│   └── domaine3
│       ├── 1024
│       │   ├── domaine3.private
│       │   └── domaine3.txt
│       ├── 4096
│       ├── domaine3.private
│       └── domaine3.txt
├── KeyTable
├── SigningTable
└── TrustedHosts

Les fichiers de signature seront placés dans un sous-répertoire /etc/opendkim.d/keys qui contiendra lui-même un dossier par domaine où seront stockées les clés. À la racine du dossier /etc/opendkim.d se trouveront les tables de hashage permettant de trouver ces clés pour chaque domaine. Toute cette arborescence sera donnée à l'utilisateur opendkim et l'on retirera tous les droits au groupe et aux autres utilisateurs. On commence par créer les fichiers de hashage et le répertoire des clés et l'on fixe leurs droits :

mkdir -p /etc/opendkim.d/keys
touch /etc/opendkim.d/KeyTable
touch /etc/opendkim.d/SigningTable
touch /etc/opendkim.d/TrustedHosts
chown -R opendkim\: /etc/opendkim.d/
chmod -R go-rwx /etc/opendkim.d/

Il faut indiquer à opendkim où il peut trouver ses table de hashage dans le fichier /etc/opendkim.conf en y ajoutant ces lignes :

KeyTable           /etc/opendkim.d/KeyTable
SigningTable       /etc/opendkim.d/SigningTable
ExternalIgnoreList /etc/opendkim.d/TrustedHosts
InternalHosts      /etc/opendkim.d/TrustedHosts

Puis l'on renseigne le fichier /etc/opendkim.d/TrustedHosts qui contiendra la liste des domaines à signer. Nous supposerons que nous avons à signer les mails pour les domaines domain1.tld, domain2.tld et domain3.tld, on remplit donc le fichier :

cat > /etc/opendkim.d/TrustedHosts << EOF
domain1.tld
domain2.tld
domain3.tld
EOF

Création des jeux de clés de signature

Il va exister un jeu de clés pour chaque domaine devant être signé. Ces clés vont être placées dans /etc/opendkim.d/keys/domain.tld/. Les deux clés seront respectivement domain.tld.private et domain.tld.txt. Le premier fichier, comme son suffixe le laisse penser, est la clé privée, le second la clé publique, mais présentée sous la forme d'un enregistrement TXT à placer dans la zone DNS.

Ces clés seront générées par l'utilitaire opendkim-genkey fourni par le paquet opendkim-tools. Si vous avez de nombreux domaines à signer vous pouvez créer un script pour exécuter ces tâches. Ici nous allons faire cela à la main pour chacun de nos trois domaines.

Commençons par créer les répertoires pour nos trois domaines :

# mkdir -p /etc/opendkim.d/keys/{domain1.tld,domain2.tld,domain3.tld}

Plaçons nous dans le premier répertoire :

cd /etc/opendkim.d/keys/domain1.tld

Une fois dans le répertoire du domaine nous allons créer son jeu de clés. L'utilitaire opendkim-genkey (voir la documentation d'opendkim-genkey) accepte une série de paramètres, certains indispensables d'autres facultatifs. Les paramètres les plus intéressants sont les suivants :

-s

Spécifie le sélecteur, ou nom, de la paire de clés générée. Sa valeur par défaut est default. Dans notre exemple j'utilise comme sélecteur le nom de domaine précédé de mail, soit domain.tld, mais sa valeur est arbitraire vous pouvez mettre ce que vous trouvez de plus parlant.

-d

Nom du domaine dont la clé devra signer les mails. Actuellement il n'est utilisé que pour un commentaire dans l'enregistrement TXT du DNS et dans le nom de la clé elle-même.

-r

Indique que la clé ne peut servir qu'à signer des mails. En regardant le code du script /usr/bin/opendkim-genkey (qui est un simple script shell) je ne vois pas comment cette limitation s'applique.

-S

Désactive la signature des sous-domaines pour cette clé. Par défaut les clés générées permettent de signer les mails venant de sous-domaines (par exemple la clé signe les messages de domain1.tld et signera aussi les messages de www.domain1.tld). Si vous savez qu'aucun sous-domaine ne doit envoyer de mails vous pouvez utiliser cette option. Mais attention car par exemple beaucoup de CMS envoient des mails avec comme nom de domaine le nom du serveur (typiquement sur debian www-data@www.domain1.tld);

-t

Indique aux programmes vérificateurs que DKIM est en test sur le serveur signataire et qu'il ne faut pas bloquer le mail en cas d'erreur. A utiliser pendant les phases de test et à retirer lorsque tout fonctionne.

-b

Nombre de bits pour la clé. La valeur par défaut est 1024.

Google et d'autres grands groupes sont passés à des clés sur plus de 1024 bits après la découverte de possibilité de casser des clés sur moins de 1024 bits. Et l'on trouve de plus en plus dans les entêtes de mail ce type d'entête :

Authentication-Results: mail.domain1.tld;
 dkim=pass (1024-bit key; insecure) header.d=domain1.tld header.i=@domain1.tld header.b=PgkAFdz5;
 dkim-adsp=pass; dkim-atps=neutral

Le serveur indique qu'il a trouvé une clé DKIM mais qu'il ne lui fait pas confiance car elle est trop courte et qu'il n'en tient pas compte. Avec ces serveurs on a travaillé pour rien avec une clé de 1024, donc je vous préconise de créer des clés de 2048 ou 4096 bits. Par contre avec certains gestionnaires de DNS (si vous passez par un prestataire pour gérer vos DNS) il faudra découper le chaîne de clé publique typiquement en tronçons inférieurs ou égaux à 255 octets. Nous verrons cela plus bas.

Dans la phase d'installation nous allons utiliser les options suivantes (blocage des sous-domaines, limitation aux mails, indicateur de phase de test, nombre de bits par défaut 2048 et utilisation de domain1.tld en tant que sélecteur).

opendkim-genkey -S -r -b 2048 -t -s domain1.tld -d domain1.tld

Deux fichiers sont produits, la clé privée et l'enregistrement à placer dans la zone DNS contenant la clé publique.

# ls -l
total 8
-rw------- 1 root root 1679 Aug  7 15:57 domain1.tld.private
-rw------- 1 root root  505 Aug  7 15:57 domain1.tld.txt

Le contenu de ces deux fichiers doit ressembler à cela (la valeur des clés ici affichées n'est pas valide, pour ne pas gâcher un jeu de clé par sa publication sur le web :)

# cat domain1.tld.private
-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQDCOK/pCko+nt18N/SLhzeVK7ekKg6KD4ijQfpq6coSi9o5g+aG
AyruixYSyUDH7+VR1kVaaHEBV8UzzpTEQCNiHvM4m/EvNerIxPKdKBwreMlqb9WH
ncH7g8Ebr+T4a0TWb7Uunl4d0gmPtAA5TqS/MoADbaPqT7Q5atvB/3ykzwIDAQAB
AoGAcogpPBykUa8vX0xD+m/fmCjyn21pq4KjidqjiJ6bWjp8ksQ0kbyWeZsthiCG
AiF2sr7PoRPL6AXRNc7RrbVA51e2MGEYdm4hUyf71NhQWJ/PxPy4/D3QXQNI7xCI
zf6oyvhELOr1GJt54KrhcK4NHzyexr8cbbc8UKpeP+9/ylECQQD9xtebxCq/ng7L
dSyB16X7SeMfm9yqRmm4bRtQpB3rtySF2qEOC9STRKcOzepByQiYOlvIdV3OAQye
m97tg3wO+zmZ7KkyZmNsKRlbAoGAMFzr5WQXJ34k2SWZhK1efFb4ioVOpiA7a1VS
zwraDcFtkAaSksjixNHy/2Jy0hI8JuTxKNO7BWIYuAh57Hlf+GLaXKvAnUTzFtlb
zjpe1ipJAkEAw+xG/HKSvIDL2gep27TF/jxwaO9qByIgTBM6/b6Flfb64Xm2L+QU
Z0suxLfh8A+9Hxmmkvi7R3U6GTuExIIWVwJAQd0Gfk3WTm8GJefzRVYMvLrCtXlr
Exm2sVINry5GNSWz39EP+nPYTa7bKnhbKNZeRRIHHvlSVXlbJzqQ2aY5yQJARg/c
YrJmHtrACzvqVhMTKpNab2wOMnbVrd7CnbLf+nzTwoXPzNh3I2kTVG2dckdujgyS
MMSZ1DfritJp7AvJCQJBAIK1z7a8j/g9P6Qgvx5830GEiPsTC0+c9Og+4KmBO62W
WsFZpAIy4lVWgTf4j+V7KpgIJB1C9HIOYP/pYJlhIBw=
-----END RSA PRIVATE KEY-----
cat domain1.tld.txt
domain1.tld._domainkey IN TXT "v=DKIM1; k=rsa; t=y:s;
p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCOK/pCko+nt18NSL
zehVK7ekKg6KD4ijQfpq6coSi9o5g+aGFPMsaisO3pypCq8q4TdPkPFR2
lqb9WHncH7g8Ebr+T4a0TWb7Uunl4d0gmPtAA5TqS/MoADbaPqT7Q5atv
B3ykzwIDAQAB" ; ----- DKIM key domain1.tld for domain1.tld

Le premier fichier domain1.tld.private est une classique clé privée rsa, l'autre fichier domain1.tld.txt est une clé publique présentée avec la syntaxe adaptée à sa copie dans la zone DNS. Quelques précisions sur cette chaîne de la clé publique. Son nom est composé du sélecteur et du nom de domaine séparés par un point et un tiret bas domain1.tld._domainkey. L'enregistrement proprement dit indique que l'on utilise DKIM (v=DKIM1) que la clé est une clé rsa (k=rsa) et le flag t (t=y:s) indique avec le y que la clé est en test et avec s qu'elle n'est pas valable pour les sous-domaine. Quand le système fonctionnera il suffira de supprimer le y dans la zone DNS pour qu'elle ne soit plus considérée comme en test.

Il suffit maintenant de répéter l'opération pour chaque domaine en allant dans le répertoire de celui-ci (on peut également indiquer un chemin absolu à opendkim-genkey en utilisant l'option -D).

On fixe les droits sur les fichiers de l'arborescence :

# chown -R opendkim\: /etc/opendkim.d/
# chmod -R go-rwx /etc/opendkim.d/

A la fin de l'opération l'arborescence doit ressembler à celle-ci :

# ll -R /etc/opendkim.d/
/etc/opendkim.d/:
total 16
drwx------ 5 opendkim opendkim 4096 Aug  6 01:55 keys
-rw------- 1 opendkim opendkim  312 Aug  6 02:26 KeyTable
-rw------- 1 opendkim opendkim  130 Aug  6 02:35 SigningTable
-rw------- 1 opendkim opendkim   32 Aug  6 02:06 TrustedHosts

/etc/opendkim.d/keys:
total 12
drwx------ 2 opendkim opendkim 4096 Aug  7 16:07 domain1.tld
drwx------ 2 opendkim opendkim 4096 Aug  7 16:08 domain2.tld
drwx------ 2 opendkim opendkim 4096 Aug  7 16:09 domain3.tld

/etc/opendkim.d/keys/domain1.tld:
total 16
-rw------- 1 root     root     1679 Aug  7 15:56 domain1.tld.private
-rw------- 1 root     root      502 Aug  7 15:56 domain1.tld.txt

/etc/opendkim.d/keys/domain2.tld:
total 16
-rw------- 1 root     root     1679 Aug  7 16:08 domain2.tld.private
-rw------- 1 root     root      502 Aug  7 16:08 domain2.tld.txt

/etc/opendkim.d/keys/domain3.tld:
total 16
-rw------- 1 root     root     1679 Aug  7 16:09 domain3.tld.private
-rw------- 1 root     root      499 Aug  7 16:09 domain3.tld.txt

Il ne reste plus qu'à remplir les tables de hashage. La table KeyTable doit comporter le nom de la clé concaténé au nom de domaine avec un point en séparateur suivi du sélecteur (qui est ici le nom de domaine) et du nom de domaine déparés par deux points et le chemin de la clé comme ceci ;

# cat /etc/opendkim.d/KeyTable
domain1.tld._domainkey.domain1.tld domain1.tld:domain1.tld:/etc/opendkim.d/keys/domain1.tld/domain1.tld.private
domain2.tld._domainkey.domain2.tld domain2.tld:domain2.tld:/etc/opendkim.d/keys/domain2.tld/domain2.tld.private
domain3.tld._domainkey.domain3.tld domain3.tld:domain3.tld:/etc/opendkim.d/keys/domain3.tld/domain3.tld.private

La table SigningTable contient pour chaque domaine le nom de la clé tel qu'il figure dans KeyTable :

# cat /etc/opendkim.d/SigningTable
domain1.tld domain1.tld._domainkey.domain1.tld
domain2.tld domain2.tld._domainkey.domain2.tld
domain3.tld domain3.tld._domainkey.domain3.tld

La configuration côté serveur est terminée, mais il reste à renseigner les enregistrments DNS.

Modifier les enregistrements DNS

Il faut que les autres serveurs de mail d'Internet puissent accéder à votre clé publique et vos informations DKIM. Cela se fait en plaçant un enregistrement TXT dans la zone DNS. Dans votre zone DNS vous devez copier la chaîne contenue dans domainx.tld.txt. Il faut pour cela bien entendu que vous ayez accès à votre zone DNS, via l'interface d'un prestataire (OVH, GANDI etc.) soit dans votre zone DNS locale si vous gérez vos DNS sur un de vos serveurs.

J'ai pu constater chez GANDI que l'interface refusait les enregistrements TXT de plus de 1024 caractères. Pour contourner cela il faut découper la chaîne de clé publique fournie par OpenDkim en tronçons de 255 caractères ou moins.

Voici ci-dessous un petit script qui permet de faire cela facilement :

#! /bin/bash

LONGKEY=$(cat$1)
SPLITEDSTRING=''
PACKETSNUMBER=0
FIRSTCAR=0
BUFF=250;

LENGTH=${#LONGKEY}
PACKETSNUMBER=$((${LENGTH}/${BUFF} + 1))

for((i = 1; i <= ${PACKETSNUMBER}; i += 1))
do
	PACKET=${LONGKEY:${FIRSTCAR}:${BUFF}}
	SPLITEDSTRING=${SPLITEDSTRING}${PACKET}
		if [ $i -ne  0 ]; then
			if [ $i -lt ${PACKETSNUMBER} ]; then
			SPLITEDSTRING=${SPLITEDSTRING}'""'
		fi
	fi
FIRSTCAR=$((${FIRSTCAR} + ${BUFF}))
done

echo${SPLITEDSTRING}

Pour l'utiliser il suffit simplement d'enregistrer ce script (par exemple sous le nom splitkey.sh), de lui donner les droits d'exécution chmod u+x et de lancer :

/chemin/vers/splitkey.sh /chemin/vers/le/fichier_de_cle_publique

Et vous afficherez la chaîne séparée par des séparateurs "". Chez moi cela donne :

# cat /etc/opendkim.d/keys/domain1.tld/domain1.tld.txt
domain1.tld._domainkey IN TXT "v=DKIM1; k=rsa; t=y; p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEApo3LcRMI1nhr5WHS9ZEKuMNMq/8PYxZjfgBho9uuGhsqDnE3sQHXgPcBrMkfvQo7JWnQJzICUC3BgP6C9+0FdFpXuAq+uKEmmh/f9Nb57GZgSFlPPnxbQ29nEZCVnW1vXBWF5/WmOMs2bgIRch9YBDotZNDydQHm+egghXHwFc3EP/pEhhbYEp5QC3HDMixaakOz/BlRhsD3IPT/pk5C3lqyRKOncxfZWZ/HC1eG8BLVQ4KQxnkZvRhSlFf2re/ZTOa4y2hApjSXrCwimyVnUCD0ywWMfGPuB6rNBDb1IWWYfnQGi/7ePNXLNFzkaloekorUXqyzYmIwaSFxDiP3akfhUxn+7PBHtIBFtxd5wML3P+lW8wqsmb8rKK7UkbqyYboL7Hngb2Y2OggOcF9sEFeJzLNEy/NsS1Rr4see5p/WvtekOedHmT5I9NzWKGVz+ut1l225VtPJ6tiGd+7WZrBub7W5/zcR6hDz176XNqHJlIKjkJJlKj+FLakh0jwo/Wk/3jxFSTbyG2i6PtvyorSdiiiY0oX9e0DkEGbK/XrFge8zT5ogqfVeRJEu/cz5ezDecAAIJI4oEOr1PCRth4w30085YiX5TuWY5zxolzu6e+Q0aM0nyT+6ZVj8ElVYi7JtEk0Ykg1hHW9yxaLvyGjuQhLsERuTKQm6JrzmWUsCAwEAAQ==" ; ----- DKIM key domain1.tld for domain1.tld

# /root/splitkey.sh /etc/opendkim.d/keys/domain1.tld/domain1.tld.txt
domain1.tld._domainkey IN TXT "v=DKIM1; k=rsa; t=y; p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEApo3LcRMI1nhr5WHS9ZEKuMNMq/8PYxZjfgBho9uuGhsqDnE3sQHXgPcBrMkfvQo7JWnQJzICUC3BgP6C9+0FdFpXuAq+uKEmmh/f9Nb57GZgSFlPPnxbQ29nEZCVnW1vXBWF5/WmOMs2bgIRch9YBDotZ""NDydQHm+egghXHwFc3EP/pEhhbYEp5QC3HDMixaakOz/BlRhsD3IPT/pk5C3lqyRKOncxfZWZ/HC1eG8BLVQ4KQxnkZvRhSlFf2re/ZTOa4y2hApjSXrCwimyVnUCD0ywWMfGPuB6rNBDb1IWWYfnQGi/7ePNXLNFzkaloekorUXqyzYmIwaSFxDiP3akfhUxn+7PBHtIBFtxd5wML3P+lW8wqsmb8rKK7UkbqyYboL7Hngb2Y2OggOcF9""sEFeJzLNEy/NsS1Rr4see5p/WvtekOedHmT5I9NzWKGVz+ut1l225VtPJ6tiGd+7WZrBub7W5/zcR6hDz176XNqHJlIKjkJJlKj+FLakh0jwo/Wk/3jxFSTbyG2i6PtvyorSdiiiY0oX9e0DkEGbK/XrFge8zT5ogqfVeRJEu/cz5ezDecAAIJI4oEOr1PCRth4w30085YiX5TuWY5zxolzu6e+Q0aM0nyT+6ZVj8ElVYi7JtEk0Ykg1hH""W9yxaLvyGjuQhLsERuTKQm6JrzmWUsCAwEAAQ==" ; ----- DKIM key domain1.tld for domain1.tld

Je vous conseille au début de votre installation de commencer par donner un TTL court (5 minutes par exemple) sur vos enregistrements DNS de manière à ce que la propagation des modifications soit rapide et de remettre un TTL normal (par exemple trois ou six heures) lorsque tout fonctionne.

Activer DKIM et vérifier son fonctionnement avant de pouvoir supprimer le flag y

Vous relancez Postfix et opendkim :

# service postfix restart
# service opendkim restart

Vous pouvez tester si DKIM est bien lancé et écoute en TCP sur le port 8891 :

# netstat -tanp | grep dkim
tcp        0      0 0.0.0.0:8891            0.0.0.0:*               LISTEN      21667/opendkim

Une fois que vous estimez que la propagation DNS a eu lieu, vous pouvez tester vos clé DKIM en utilisant des services en ligne comme DkimCore. Vous pouvez également tester DKIM en envoyant un message à l’adresse check-auth@verifier.port25.com, qui répond automatiquement avec un diagnostic complet.

Maintenant vos mails devraient être signés par DKIM en passant par votre serveur et présenter un entête de ce genre ;

DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=domain1.tld;
 s=domain1.tld; t=1407344673;
 bh=vDMlP96Y4g9V1+aT6DLr18wvWrcgJ6RHivg0kh9DfDk=;
 h=Date:From:To:Subject:From;
 b=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDCOK/pCko+nt18N
   /SLzehVK7ekKg6KD4ijQfpq6coSi9o5g+aGAyruixYSyUDH7+VR1k
   VaaHEBV8UzzpTEQCNiHvM4m/EvNerIxPKdKBwreMlqb9WHncH7g8E
   br+T4a0TWb7Uunl4d0gmPtAA5TqS/MoADbaPqT7Q5atvB/3ykzwID
   AQAB=

Quand tout fonctionne n'oubliez pas de retirer le flag y de l'enregistrement DNS et de remettre des TTL longs.

Faire signer par dkim les mails envoyés avec roundcube

Par défaut roundcube envoit les mails avec la fonction mail de php, et du coup court-circuite le serveur. Pour avoir les signatures DKIM il faut le forcer à passer par le serveur. Pour cela il faut apporter quelques modifications au fichier /etc/roundcube/main.inc.php] :

$rcmail_config['smtp_server'] = 'tls://%n';
$rcmail_config['smtp_user'] = '%u';
$rcmail_config['smtp_pass'] = '%p';

Ressources consultées

• Site officiel OpenDkim : http://www.opendkim.org/
• OpenDKIM & Postfix sur debian squeeze
• Configuration de DKIM sur Debian Wheezy 7Août 2017 la page n'existe plus.
• Dkim sous Postfix avec plusieurs domaines
• Vérifier une clé DKIM publiée : http://dkimcore.org/tools/keycheck.html