web-dev-qa-db-fra.com

Utiliser DKIM sur mon serveur pour plusieurs domaines (sites Web)

J'ai lu le tutoriel posté par MountainX ( Setup DKIM (DomainKeys) pour Ubuntu, Postfix et Mailman ), mais je ne vois pas comment appliquer ces étapes si je souhaite héberger et envoyer des e -mails pour plusieurs domaines. Est-ce que quelqu'un a un indice?

postfixdkim
21
Diego

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

Alors 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 à la racine pour simplifier les choses, mais vous pouvez ignorer cette étape et utiliser Sudo avant chaque commande.

Sudo su

Maintenant, nous installons OpenDKIM:

apt-get install opendkim opendkim-tools

Réparons le fichier de configuration. Nous ouvrons /etc/opendkim.conf pour le modifier. 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 les noms Domain, KeyFile et Selector doivent rester commentés.

# 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 doit utiliser et traiter. Pour l'instant, le fichier TrustedHosts. Nous créons et éditons:

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, ainsi que votre nom de serveur et votre IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Nous modifions maintenant le fichier de configuration OpenDKIM.

nano /etc/default/opendkim

Et ajoutez ces lignes à la fin du fichier. Ils indiqueront à OpenDKIM dans quel port il doit 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 les courriels à 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 pour 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 identique pour tous les domaines que vous souhaitez ajouter. Je vais utiliser otherdomain.com pour l'exemple, je le remplacerai par le vôtre.

Rappelez-vous que j'étais auparavant root, mais si ce n'est pas le cas, exécutez Sudo su ou faites précéder vos commandes du mot clé Sudo.

Sudo su

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

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 fichier KeyTable pour ajouter notre nouvelle clé à 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 fichier SigningTable.

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

This SigningTable liste tous les mails qui sont signés. En ajoutant simplement un nom de domaine, tous les courriers de ce domaine seront signés.

Je ne suis pas sûr de la nécessité de passer à l'étape suivante, mais je viens de le faire, juste au cas où ... Nous ouvrons le fichier TrustedHosts.

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 enregistrement TXT dans la zone DNS du domaine, et nous devons également utiliser default._domainkey comme 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é!

30
Diego

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 de domaines = ().

Commencez par créer les fichiers et les 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 contient tous les enregistrements spf que vous devez ajouter à vos enregistrements DNS pour chaque domaine.

REMARQUE: ne pas exécuter 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
4
Radium

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 du type "exemple.com" par ligne dans le tableau de 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. Il vérifie la 2e ligne de default.txt avec spfs.txt avant l'ajout.

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 vérifications ajoutées.

#!/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
3
Belldandu