Mise en cohérence de la page et de la procédure standard

This commit is contained in:
whirigoyen 2024-04-17 18:25:47 +02:00
parent e516fcaa81
commit 2943c6e39a

View file

@ -58,6 +58,7 @@ opendkim: OpenDKIM Filter v2.11.0
└─18086 /usr/sbin/opendkim -x /etc/opendkim.conf
~~~
## Configuration
La configuration principale se trouve dans le fichier `/etc/opendkim.conf`.
@ -66,18 +67,22 @@ La configuration principale se trouve dans le fichier `/etc/opendkim.conf`.
**Note 2** : Depuis Debian 9, l'unité systemd charge seulement `/etc/opendkim.conf` et non plus `/etc/default/opendkim`.
Les options de configuration se combinent principalement sur deux modes :
Nous utilisons le mode de configuration le plus flexible, avec plusieurs clés privées possible (méthode conseillée) :
* Configuration par domaine d'expédition (conseillée) :
* `/etc/opendkim/KeyTable` : liste des clés privées / sélecteurs
* `/etc/opendkim/SigningTable` : clés privées à utiliser en fonction de l'adresse `From:`
* Configuration avec une seule clé privée (méthode dépréciée chez Evolix) :
* `/etc/opendkim/Domain` : liste des domaines acceptés
* `/etc/opendkim/KeyFile` : clé privée
* `/etc/opendkim/Selector` : nom de la clé dans l'enregistrement DNS
* Pas de `KeyTable` ni de `SigningTable`
* `KeyTable` : fichier contenant la liste des clés privées (des sélecteurs DNS correspondants).
* `SigningTable` : fichier contenant la table de correspondance entre les l'adresse `From:` et les clés privées pour signer.
### Configuration par domaine d'expédition, avec une ou plusieurs clés privées
Il est aussi possible de simplifier en n'utilisant qu'une seule clé privée :
* `Domain` : fichier contenant la liste des domaines acceptés.
* `KeyFile` : clé privée (unique).
* `Selector` : sélecteur DNS (unique).
* Pas de `KeyTable` ni de `SigningTable`.
### Configuration multi-clés privées (méthode conseillée)
#### Première configuration
~~~
# cat /etc/opendkim.conf
@ -99,65 +104,47 @@ SigningTable refile:/etc/opendkim/SigningTable
KeyTable refile:/etc/opendkim/KeyTable
~~~
**Le fichier `/etc/opendkim/KeyTable` définit les clés privées et leur sélecteur :**
Note : Un **sélecteur DNS** permet aux clients mails de récupérer la clé publique, pour vérifier la signature DKIM. On le met en sous-domaine du domaine : `<SELECTOR>._domainkey.example.com`.
**Générer une clé** avec les commandes :
~~~
key1 example.com:key1_selector:/etc/ssl/private/dkim_example.com.key
key2 example.org:key2_selector:/etc/ssl/private/dkim_example.org.key
# opendkim-genkey -h sha256 -b 4096 -D /etc/ssl/private/ -s dkim-<HOSTNAME>-key1 -v
opendkim-genkey: generating private key
opendkim-genkey: private key written to dkim-<HOSTNAME>-key1.private
opendkim-genkey: extracting public key
opendkim-genkey: DNS TXT record written to dkim-<HOSTNAME>-key1.txt
# mv /etc/ssl/private/dkim-<HOSTNAME>-key1.{private,key1}
# chown opendkim:opendkim /etc/ssl/private/dkim-<HOSTNAME>-key1.key
# chmod 640 /etc/ssl/private/dkim-<HOSTNAME>-key1.key
~~~
Un **sélecteur** est une expression qui sert aux clients à trouver le sous-domaine de l'enregistrement TXT qui contient la clé publique DKIM du domaine (via `<SELECTOR>._domainkey.example.com`).
Si on a plusieurs serveurs de messagerie (et donc plusieurs clé privées), des sélecteurs différents permettent d'avoir plusieurs clés publiques associées à un même domaine, dans des enregistrements TXT de différents sous-domaines.
On peut utiliser un même sélecteur et clé privée pour plusieurs domaines (pratique sur les serveurs avec beaucoup de domaines) ainsi :
Ajouter la **clé privée**, que l'on nomme `key1`, et son **sélecteur DNS** dans `/etc/opendkim/KeyTable` :
~~~
key1 %:key1_selector:/etc/ssl/private/dkim_my_mail_server.key
key1 %:dkim-<HOSTNAME>-key1:/etc/ssl/private/dkim-<HOSTNAME>.key
~~~
**Le fichier `/etc/opendkim/SigningTable` indique quelle clé utiliser pour signer en fonction du champ `From:` :**
Note : s'il y a déjà une clé pour un domaine, on peut remplacer le domaine par `%`, ou bien ajouter la nouvelle clé à la suite (en la renommant `key2`) :
~~~
*@example.com key1
*@example.org key2
old_key example.com:old_key_selector:old_key_path
key2 %:dkim-<HOSTNAME>-key2:/etc/ssl/private/dkim-<HOSTNAME>-key2.key
~~~
Les lignes sont traitées dans l'ordre, seul le premier match est utilisé, sauf si `MultipleSignatures` est activé.
**Pour générer une clé**, on utilise la commande :
~~~
# opendkim-genkey -h sha256 -b 4096 -D /etc/ssl/private/ -d example.com -s foo -v
opendkim-genkey: generating private key
opendkim-genkey: private key written to foo.private
opendkim-genkey: extracting public key
opendkim-genkey: DNS TXT record written to foo.txt
# mv /etc/ssl/private/foo.private /etc/ssl/private/dkim_example.com.key
# chown opendkim:opendkim /etc/ssl/private/dkim_example.com.key
# chmod 640 /etc/ssl/private/dkim_example.com.key
~~~
Il faut ensuite **publier l'enregistrement DNS** à partir du fichier `/etc/ssl/private/foo.txt` généré, en ajoutant la ligne suivante dans la zone DNS du domaine en question :
~~~
foo._domainkey IN TXT ( "v=DKIM1; h=sha256; k=rsa; "
"p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtdnoCyrwNyCAttQz0VaJq3cheWtki8KTfCwPu+QDcyv8IHLpQGK2UsEw03epEjTI/ijdyyVsElDPoqsCZ4+R3H5I41Vj8xcGLvqIaG3mbgOhcxuD+eEPR1K+JbSptwMiP/oja7VFyftQtx5XkQh8oj458WR/EE++SzjOGXOVmFYzf+LnNXJ/Rc0avAUPcTF1NmoU8IP52aKTvw"
"nrbPFhIPkUyIR1/5k+5h4ZJqY+2h+JqDuol0E73Yl79rsF5ycjwLtBCPsz80jzCpOF5YHkDx0CYPyTKoIA3eZlgOVSJPmDYUWCrj/9k2bL/nSL5EJoB/X/kQcLRTy83dqf+gzWd850yP9vpUQQ2d+Z1hdlAFvzVMboSNz12+au7kAglXmN47l9Z8igxVWJfl7BEsegQF8gYPB4yepSW3DtfxBC5zCjLYYN1xXabf3wZfeCF6yOoQk1C2yN"
"ThvBa4NyQDWizZGs4t9eHTR8QHMzJogPQQvyS45ILN1HHeikIQZP/lormmFQzq9X8sDGt4Edy8A3OMLjHom81tP6zxb4I8Pq0V4bEt4m4KA+K89A+b9cTD2Xr/wbqgQ1nwTcnEfGgBxbc3iRKkUnwhjeIocsxmwHqmDIVV8HKB5egUg8US/eo9al8w4JYEdzx9tETW/5dQOeLTMVw2N0/A7M9zVbBQEyuaMCAwEAAQ==" ) ; ----- DKIM key foo for example.com
~~~
On utilise le fichier `/etc/opendkim/dkim.peers` pour mettre la liste des adresses IP autorisées à envoyer des messages pour lesquels on va rajouter une signature DKIM (a priori des serveurs SMTP internes uniquement) :
Mettre dans le fichier `/etc/opendkim/dkim.peers` la liste des adresses IP autorisées à ajouter une signature DKIM aux messages (a priori des serveurs SMTP internes uniquement) :
~~~
127.0.0.1
::1
192.0.2.142
192.0.2.0/25
#192.0.2.142
#192.0.2.0/25
~~~
On ajuste les droits ainsi :
Ajuster les droits :
~~~
# chown -R opendkim:opendkim /etc/opendkim*
@ -165,14 +152,57 @@ On ajuste les droits ainsi :
# chmod 750 /etc/opendkim/
~~~
Et l'on peut enfin démarrer le démon :
Enfin, démarrer le démon :
~~~
# systemctl start opendkim
$ systemctl status opendkim
~~~
### Configuration avec une seule clé privée (deprecated)
#### Ajouter un domaine à signer
**Le fichier `/etc/opendkim/SigningTable` indique le nom de la clé privée (définit dans `/etc/opendkim/KeyTable`) à utiliser pour signer un message en fonction de son champ `From:`** :
~~~
*@example.com key1
*@example.org key1
~~~
S'il n'existe pas, ne pas oublier d'ajuster les droits :
~~~
# chown -R opendkim:opendkim /etc/opendkim/KeyTable
# chmod 640 /etc/opendkim.conf /etc/opendkim/KeyTable
~~~
S'il y a plusieurs clés, pourra mettre :
~~~
*@example.com old_key
*@example1.org key2
*@example2.org key2
~~~
Puis, recharger OpenDKIM :
~~~
$ systemctl reload opendkim
$ systemctl status opendkim
~~~
Ensuite, récupérer l'enregistrement DNS dans `/etc/ssl/private/dkim-<HOSTNAME>-key1.txt` (généré à la création de la clé privée), et l'ajouter dans la zone DNS du domaine en question :
~~~
dkim-<HOSTNAME>-key1._domainkey IN TXT ( "v=DKIM1; h=sha256; k=rsa; "
"p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtdnoCyrwNyCAttQz0VaJq3cheWtki8KTfCwPu+QDcyv8IHLpQGK2UsEw03epEjTI/ijdyyVsElDPoqsCZ4+R3H5I41Vj8xcGLvqIaG3mbgOhcxuD+eEPR1K+JbSptwMiP/oja7VFyftQtx5XkQh8oj458WR/EE++SzjOGXOVmFYzf+LnNXJ/Rc0avAUPcTF1NmoU8IP52aKTvw"
"nrbPFhIPkUyIR1/5k+5h4ZJqY+2h+JqDuol0E73Yl79rsF5ycjwLtBCPsz80jzCpOF5YHkDx0CYPyTKoIA3eZlgOVSJPmDYUWCrj/9k2bL/nSL5EJoB/X/kQcLRTy83dqf+gzWd850yP9vpUQQ2d+Z1hdlAFvzVMboSNz12+au7kAglXmN47l9Z8igxVWJfl7BEsegQF8gYPB4yepSW3DtfxBC5zCjLYYN1xXabf3wZfeCF6yOoQk1C2yN"
"ThvBa4NyQDWizZGs4t9eHTR8QHMzJogPQQvyS45ILN1HHeikIQZP/lormmFQzq9X8sDGt4Edy8A3OMLjHom81tP6zxb4I8Pq0V4bEt4m4KA+K89A+b9cTD2Xr/wbqgQ1nwTcnEfGgBxbc3iRKkUnwhjeIocsxmwHqmDIVV8HKB5egUg8US/eo9al8w4JYEdzx9tETW/5dQOeLTMVw2N0/A7M9zVbBQEyuaMCAwEAAQ==" ) ; ----- DKIM key dkim-<HOSTNAME>-key1 for localhost
~~~
### Configuration simplifiée avec une seule clé privée (non utilisé à Evolix)
Générer une paire de clés avec le sélecteur `dkim-<SERVER_NAME>` (par exemple) dans le répertoire `/etc/opendkim/keys/` :
@ -221,7 +251,8 @@ Selector dkim-<SERVER_NAME>
Domain refile:/etc/opendkim/domains_whitelist
~~~
#### Ajouter un domaine à OpenDKIM
**Pour ajouter un domaine :**
Ajouter le texte contenu dans le fichier `/etc/opendkim/keys/dkim-<SERVER_NAME>.txt` aux enregistrements DNS du domaine.
Cela va rendre la clé publique accessible via un enregistrement TXT du sous-domaine `dkim-<SERVER_NAME>._domainkey.$domain`.
@ -242,7 +273,7 @@ Puis, ajouter le domaine à la liste `/etc/opendkim/domains_whitelist` et redém
~~~
## Ajout dans Postfix
## Configurer Postfix pour utiliser OpenDKIM
Pour configurer avec [Postfix](HowtoPostfix) on ajoute simplement les instructions suivantes dans le fichier `/etc/postfix/main.cf` :
@ -273,23 +304,25 @@ opendkim[18086]: 8A836229A8: not authenticated
opendkim[18086]: 2760F22B59: DKIM-Signature field added (s=dkim-foo, d=google.com)
~~~
## Vérifications
### Vérifier la configuration
### Vérifier les clés et la configuration DNS
On peut vérifier que la configuration est correcte, notamment l'enregistrement DNS (si la commande ne renvoie rien, c'est que c'est OK) :
~~~
# opendkim-testkey -d example.com -s foo -k /etc/ssl/private/dkim_example.com.key -v
# opendkim-testkey -d example.com -s <SELECTOR> -k /etc/ssl/private/dkim_example.com.key -v
opendkim-testkey: /etc/ssl/private/dkim_example.com.key: WARNING: unsafe permissions
opendkim-testkey: key not secure
~~~
> *Note* : vous pouvez ignorer le warning des permissions si vous avez correctement ajusté les droits comme précisé plus haut
### Vérifier la signature DKIM d'un mail
Il faut envoyer un email de test avec un expéditeur d'en-tête correct. Par exemple, en ligne de commande :
A partir du serveur, il faut s'envoyer un email de test (avec un expéditeur d'en-tête correct). Par exemple, en ligne de commande :
~~~
$ telnet 127.0.0.1 25
@ -305,7 +338,7 @@ Ceci est un test
.
~~~
La source de l'email devrait avoir un en-tête supplémentaire du type :
A la réception, la source de l'email devrait contenir un en-tête supplémentaire du type :
~~~
DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=example.com; s=foo;
@ -332,6 +365,7 @@ Sinon, si vous avez accès à un email Gmail ou Yahoo, vous pouvez lui envoyer u
Il est important de s'assurer que le démon *opendkim* tourne en permanence.
### Nagios
Voici un check basique pour vérifier que le port TCP d'*opendkim* répond bien :
@ -340,6 +374,7 @@ Voici un check basique pour vérifier que le port TCP d'*opendkim* répond bien
$ /usr/lib/nagios/plugins/check_tcp -H 127.0.0.1 -p 8891
~~~
### log2mail
Pour être alerté en cas de *warning: connect to Milter service inet:8891: Connection refused
@ -450,15 +485,18 @@ Lorsqu'une clé a déjà été générée mais que le fichier contenant la zone
opendkim-genzone -F -d example.com /etc/opendkim/KeyTable
~~~
### body hash did not verify
Cette erreur vient du fait que le payload du message a été modifié par un serveur SMTP entre le départ et l'arrivée (inclus).
Cela peut venir de lignes trop longues (cf plus bas).
### Lignes trop longues
D'après <https://www.rfc-editor.org/rfc/rfc2822#section-2.1.1> les lignes d'un email ne doivent pas être trop longues sinon elles peuvent se faire découper par un serveur SMTP entre le départ et l'arrivée (inclus)... ce qui changer le payload du message car il aura notamment des sauts de ligne en plus.. et donc le body hash de la signature DKIM ne sera plus valide.
### Signer tous les emails avec la même clé ?
Pour signer tous les domaines avec un même clé, on peut mettre un *wildcard* dans `/etc/opendkim/SigningTable` :
@ -467,4 +505,4 @@ Pour signer tous les domaines avec un même clé, on peut mettre un *wildcard* d
* key1
~~~
Mais c'est déconseillé car tous les emails car OpenDKIM tenteraient de traiter tous les domaines, et cela peut poser des problèmes avec des emails tordus (par exemple OpenDKIM plante quand on trouve une [espace sans chasse](https://fr.wikipedia.org/wiki/Espace_sans_chasse) dans le nom de domaine)
Mais c'est déconseillé car tous les emails car OpenDKIM tenteraient de traiter tous les domaines, et cela peut poser des problèmes avec des emails tordus (par exemple OpenDKIM plante quand on trouve une [espace sans chasse](https://fr.wikipedia.org/wiki/Espace_sans_chasse) dans le nom de domaine).