Utilisation de DKIM sur mon serveur pour plusieurs domaines (sites Web)

J'ai lu le tutoriel publié par MountainX ( Setup DKIM (DomainKeys) pour Ubuntu, Postfix et Mailman ), mais je ne sais pas comment appliquer ces étapes si je veux héberger et envoyer des e-mails pour plusieurs domaines. Quelqu'un a-t-il une idée?

Bien! Je l'ai compris dans le message mentionné dans la question. J'ai fait une sorte de mélange entre la réponse elle-même et les liens qu'elle contient. Surtout le quatrième lien est celui que j'ai utilisé.

Donc, la chose se passe comme ça. Supposons que vous ayez un serveur ou un VPS et que l'un de vos domaines soit le domaine principal et soit utilisé comme nom de serveur (dans mon exemple: mydomain.com).

Donc, tout d'abord, nous allons passer à root pour faciliter les choses, mais vous pouvez ignorer cette étape et utiliser sudoavant chaque commande.

sudo su

Maintenant, nous installons OpenDKIM:

apt-get install opendkim opendkim-tools

Corrigeons le fichier de configuration. Nous ouvrons /etc/opendkim.confpour l'édition. J'utilise nano, mais c'est la même chose avec un autre éditeur.

nano /etc/opendkim.conf

Une fois ouvert, faites-le ressembler à ceci. Si vous vous sentez à l'aise, vous pouvez modifier certaines options, mais le Domain, KeyFileet Selectordoit rester commenté.

# This is a basic configuration that can easily be adapted to suit a standard
# installation. For more advanced options, see opendkim.conf(5) and/or
# /usr/share/doc/opendkim/examples/opendkim.conf.sample.
#
#Domain                  example.com
#KeyFile                 /etc/opendkim/201205.private
#Selector                201205
#
# Commonly-used options
Canonicalization        relaxed/simple
Mode                    sv
SubDomains              yes
# Log to syslog
Syslog                  yes
LogWhy                  yes
# Required to use local socket with MTAs that access the socket as a non-
# privileged user (e.g. Postfix)
UMask                   022
UserID                  opendkim:opendkim
#
KeyTable                /etc/opendkim/KeyTable
SigningTable            /etc/opendkim/SigningTable
ExternalIgnoreList      /etc/opendkim/TrustedHosts
InternalHosts           /etc/opendkim/TrustedHosts
#
Socket                  inet:8891@localhost
#EOF

Ensuite, nous créons certains dossiers et fichiers qui contiendront des informations sur ce que OpenDKIM devrait utiliser et traiter. Pour l'instant, le TrustedHostsfichier. Nous le créons et le modifions:

mkdir /etc/opendkim
nano /etc/opendkim/TrustedHosts

Nous devons mettre dans ce fichier une liste d'adresses de confiance: localhost et 127.0.0.1, et votre nom de serveur et IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Maintenant, nous éditons le fichier de configuration OpenDKIM.

nano /etc/default/opendkim

Et ajoutez ces lignes à la fin du fichier. Ils diront à OpenDKIM dans quel port il devrait s'attendre à des demandes de signature:

SOCKET="inet:8891@localhost"

Nous ouvrons le fichier de configuration Postfix.

nano /etc/postfix/main.cf

Et ajoutez ces lignes à la fin du fichier. Ils diront à Postfix qu'il doit envoyer des e-mails à signer et où.

milter_default_action = accept
milter_protocol = 6
smtpd_milters = inet:localhost:8891
non_smtpd_milters = inet:localhost:8891

Si vous n'ajoutez pas de domaines pour le moment, vous pouvez tout redémarrer, afin que la configuration prenne effet.

/etc/init.d/opendkim restart
/etc/init.d/postfix reload
/etc/init.d/postfix restart

Terminé! Le serveur est prêt à fonctionner avec DKIM. Maintenant, vous devez ajouter vos domaines à ce système. Le processus suivant est le même pour tous les domaines que vous souhaitez ajouter. Je vais utiliser otherdomain.com pour l'exemple, remplacez-le par le vôtre.

N'oubliez pas que j'étais root d'avant, mais si vous ne l'êtes pas, exécutez sudo suou faites précéder vos commandes avec le mot-clé sudo.

sudo su

Tout d'abord, nous créons un répertoire pour notre domaine et allons à l'intérieur de celui-ci:

mkdir -p /etc/opendkim/keys/otherdomain.com
cd /etc/opendkim/keys/otherdomain.com

Maintenant, nous générons une clé pour le domaine:

opendkim-genkey -r -d otherdomain.com

Nous donnons à l'utilisateur OpenDKIM la propriété du fichier nouvellement créé:

chown opendkim:opendkim default.private

Et nous ouvrons le KeyTablefichier pour ajouter notre nouvelle clé pour notre nouveau domaine:

nano /etc/opendkim/KeyTable

Nous l'ajoutons à la fin du fichier (après tous les autres domaines que nous pouvons avoir ici):

default._domainkey.otherdomain.com otherdomain.com:default:/etc/opendkim/keys/otherdomain.com/default.private

Nous ouvrons le SigningTabledossier.

nano /etc/opendkim/SigningTable

Et ajoutez à la fin du fichier (encore une fois, nous aurons une ligne pour chaque domaine):

otherdomain.com default._domainkey.otherdomain.com

Cette table de signature répertorie tous les e-mails qui sont signés. En ajoutant simplement un nom de domaine, tous les e-mails de ce domaine seront signés.

Je ne suis pas sûr de la nécessité de faire la prochaine étape, mais je viens de le faire, juste au cas où ... Nous ouvrons le TrustedHostsfichier.

nano /etc/opendkim/TrustedHosts

Et ajoutez à la fin du fichier:

otherdomain.com

Une dernière chose: nous montrons le contenu du fichier /etc/opendkim/keys/otherdomain.com/default.txt.

cat /etc/opendkim/keys/otherdomain.com/default.txt

Et ajoutez les informations entre les guillemets à un TXTenregistrement dans la zone DNS du domaine, et nous devons également utiliser default._domainkeycomme nom de l'enregistrement. REMARQUE: "entre les guillemets" est le texte qui commence par " v=DKIM1;k=rsa; p=WIGfM...".

Si nous avons fini d'ajouter des domaines (maintenant), nous redémarrons tout pour appliquer les modifications.

/etc/init.d/opendkim restart
/etc/init.d/postfix reload
/etc/init.d/postfix restart

Terminé!

Ce script automatise la partie après "Terminé! Le serveur est prêt à fonctionner avec DKIM"

Pour aider à automatiser un peu ce processus, j'ai créé ce script bash. Ajoutez simplement un «domaine.com» par ligne dans le tableau domaines = ().

Créez d'abord les fichiers et répertoires s'ils n'existent pas déjà

/etc/opendkim/keys/
/etc/opendkim/KeyTable
/etc/opendkim/SigningTable
/etc/opendkim/TrustedHosts
/etc/opendkim/spfs.txt

Le fichier spfs.txt contiendra tous les enregistrements spf que vous devez ajouter à vos enregistrements DNS pour chaque domaine.

REMARQUE: n'exécutez pas plus d'une fois, il ne vérifie pas si un domaine existe déjà. Le script doit également être exécuté en tant que root.

#!/bin/bash
domains=(
        'domain.com'
)
for domain in "${domains[@]}"
do
keydir="/etc/opendkim/keys/$domain"
if [ -d "$keydir" ]
then
cd $keydir
else
mkdir $keydir
cd $keydir
fi
opendkim-genkey -r -d $domain
chown opendkim:opendkim default.private
echo "default._domainkey.$domain $domain:default:$keydir/default.private" >> /etc/opendkim/KeyTable
echo "$domain default._domainkey.$domain" >> /etc/opendkim/SigningTable
echo "$domain" >> /etc/opendkim/TrustedHosts
echo "$(cat $keydir/default.txt)" >> spfs.txt
done

Ce script automatise la partie après "Terminé! Le serveur est prêt à fonctionner avec DKIM"

Pour aider à automatiser un peu ce processus, j'ai créé ce script bash. Ajoutez simplement un domaine comme 'example.com' par ligne dans le tableau domaines = ().

Ce script crée les fichiers pour vous et vérifie si une ligne est déjà dans le fichier

Spfs.txt est supprimé et recréé à chaque exécution et vérifie la deuxième ligne de default.txt par rapport à spfs.txt avant d'ajouter

Vous devez placer vos serveurs ipv4 et ipv6 (si vous en avez) dans les variables fournies. Il vérifie s'ils ne sont pas vides

vous pouvez exécuter ce fichier plusieurs fois grâce aux contrôles ajoutés.

#!/bin/bash
# List of domains
domains=( 
        'example.com'
)
# file paths and directories
dkim="/etc/opendkim"
keys="$dkim/keys"
keyfile="$dkim/KeyTable"
signfile="$dkim/SigningTable"
trustfile="$dkim/TrustedHosts"
spffile="$dkim/spfs.txt"
# Set Ipv6 and Ipv4 addresses for the server here
ipv4=""
ipv6=""
# loopback addresses for the server
loop=( localhost 127.0.0.1 )
function loopback {
        for back in "${loop[@]}"
        do
                if ! grep -q "$back" "$trustfile"; then
                        echo "$back" >> "$trustfile"
                fi
        done
}
# Check for files and create / write to them if they dont exist
if [ ! -d "$keys" ]; then
        mkdir "$keys"
fi
if [ ! -f "$keyfile" ]; then
        touch "$keyfile"
fi
if [ ! -f "$signfile" ]; then
        touch "$signfile"
fi
if [ ! -f "$trustfile" ]; then
        touch "$trustfile"
        loopback
else
        loopback
fi
if [ ! -f "$spffile" ]; then
        touch "$spffile"
else
        rm -rf "$spffile"
        touch "$spffile"
fi
if [ ! -z "$ipv6" ]; then
        if ! grep -q "$ipv6" "$trustfile"; then
                echo "$ipv6" >> "$trustfile"
        fi
fi
if [ ! -z "$ipv4" ]; then
        if ! grep -q "$ipv4" "$trustfile"; then
                echo "$ipv4" >> "$trustfile"
        fi
fi
# Generate keys and write the spfs records we need for each domain to one file
for domain in "${domains[@]}"
do
        keydir="$keys/$domain"
        default="$keydir/default.txt"
        if [ ! -d "$keydir" ]; then
                mkdir $keydir
        fi
        cd $keydir
        opendkim-genkey -r -d $domain
        chown opendkim:opendkim default.private
        key="default._domainkey.$domain $domain:default:$keydir/default.private"
        sign="$domain default._domainkey.$domain"
        trust="$domain"
        spf="$(cat $default)"
        # Check only the last line against the spf file as the first line is always the same
        spflast="$(tail -1 $default)"
        if ! grep -q "$key" "$keyfile"; then
                echo "$key" >> "$keyfile"
        fi
        if ! grep -q "$sign" "$signfile"; then
                echo "$sign" >> "$signfile"
        fi
        if ! grep -q "$trust" "$trustfile"; then
                echo "$trust" >> "$trustfile"
        fi
        if ! grep -q "$spflast" "$spffile"; then
                echo "$spf" >> "$spffile"
        fi
done