Verwenden von DKIM auf meinem Server für mehrere Domains (Websites)

Ich habe das Tutorial von MountainX ( Setup DKIM (DomainKeys) für Ubuntu, Postfix und Mailman ) gelesen , kann aber nicht herausfinden, wie diese Schritte angewendet werden, wenn ich E-Mails für mehrere Domains hosten und senden möchte. Hat jemand eine Ahnung?

Gut! Das habe ich aus dem in der Frage genannten Beitrag herausgefunden. Ich habe eine Art Mischung zwischen der Antwort selbst und den darin enthaltenen Links gemacht. Insbesondere der vierte Link ist derjenige, den ich verwendet habe.

Also geht die Sache so. Angenommen, Sie haben einen Server oder ein VPS und legen fest, dass eine Ihrer Domänen die Hauptdomäne ist und als Servername verwendet wird (in meinem Beispiel: mydomain.com).

Daher werden wir zunächst zu root wechseln, um die Arbeit zu vereinfachen. Sie können diesen Schritt jedoch überspringen und sudovor jedem Befehl ausführen.

sudo su

Jetzt installieren wir OpenDKIM:

apt-get install opendkim opendkim-tools

Korrigieren wir die Konfigurationsdatei. Wir öffnen /etc/opendkim.confzur Bearbeitung. Ich benutze Nano, aber es ist das gleiche mit anderen Editoren.

nano /etc/opendkim.conf

Nach dem Öffnen sollte es so aussehen. Wenn Sie sich wohl fühlen, können Sie einige Optionen ändern, aber das Domain, KeyFileund Selectormuss kommentiert bleiben.

# 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

Als nächstes erstellen wir einige Ordner und Dateien, die Informationen darüber enthalten, was OpenDKIM verwenden und verarbeiten soll. Vorerst die TrustedHostsDatei. Wir erstellen und bearbeiten es:

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

Wir müssen in diese Datei eine Liste vertrauenswürdiger Adressen einfügen: localhost und 127.0.0.1 sowie Ihren Servernamen und Ihre IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Jetzt bearbeiten wir die OpenDKIM-Konfigurationsdatei.

nano /etc/default/opendkim

Fügen Sie diese Zeilen am Ende der Datei hinzu. Sie teilen OpenDKIM mit, an welchem ​​Port Signaturanforderungen zu erwarten sind:

SOCKET="inet:8891@localhost"

Wir öffnen die Postfix-Konfigurationsdatei.

nano /etc/postfix/main.cf

Fügen Sie diese Zeilen am Ende der Datei hinzu. Sie teilen Postfix mit, dass E-Mails gesendet werden sollen, die signiert werden sollen, und wohin.

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

Wenn Sie gerade keine Domains hinzufügen, können Sie alles neu starten, damit die Konfiguration wirksam wird.

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

Getan! Der Server ist bereit, mit DKIM zu arbeiten. Nun müssen Sie Ihre Domains zu diesem System hinzufügen. Der folgende Vorgang ist für alle Domänen, die Sie hinzufügen möchten, gleich. Ich werde otherdomain.com für das Beispiel verwenden und es durch Ihr eigenes ersetzen.

Denken Sie daran, dass ich zuvor root war. Wenn dies nicht der sudo suFall ist, führen Sie Ihren Befehlen das Schlüsselwort aus oder stellen Sie es voran sudo.

sudo su

Zuerst erstellen wir ein Verzeichnis für unsere Domain und gehen hinein:

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

Jetzt generieren wir einen Schlüssel für die Domain:

opendkim-genkey -r -d otherdomain.com

Wir geben dem OpenDKIM-Benutzer den Besitz der neu erstellten Datei:

chown opendkim:opendkim default.private

Und wir öffnen die KeyTableDatei, um unseren neuen Schlüssel für unsere neue Domain hinzuzufügen:

nano /etc/opendkim/KeyTable

Wir fügen es am Ende der Datei hinzu (nach allen anderen Domänen, die wir hier haben können):

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

Wir öffnen die SigningTableDatei.

nano /etc/opendkim/SigningTable

Und hängen Sie am Ende der Datei an (wieder haben wir eine Zeile für jede Domain):

otherdomain.com default._domainkey.otherdomain.com

Diese SigningTable listet alle Mails auf, die signiert werden. Durch Hinzufügen eines Domainnamens werden alle Mails dieser Domain signiert.

Ich bin mir nicht sicher, ob es notwendig ist, den nächsten Schritt zu tun, aber ich habe es einfach getan, nur für den Fall ... Wir öffnen die TrustedHostsDatei.

nano /etc/opendkim/TrustedHosts

Und füge am Ende der Datei hinzu:

otherdomain.com

Eine letzte Sache: Wir zeigen den Inhalt der Datei /etc/opendkim/keys/otherdomain.com/default.txt.

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

Fügen Sie die Informationen zwischen den Anführungszeichen zu einem TXTEintrag in der DNS-Zone der Domäne hinzu, und verwenden Sie außerdem default._domainkeyden Namen des Eintrags. HINWEIS: "zwischen den Anführungszeichen" ist der Text, der mit " v=DKIM1;k=rsa; p=WIGfM..." beginnt .

Wenn wir (bis jetzt) ​​keine Domänen mehr hinzugefügt haben, starten wir alles neu, um die Änderungen zu übernehmen.

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

Getan!

Dieses Skript automatisiert den Teil nach "Fertig! Der Server ist bereit, mit DKIM zu arbeiten".

Um diesen Prozess ein wenig zu automatisieren, habe ich dieses Bash-Skript erstellt. Fügen Sie einfach eine 'domain.com' pro Zeile in das Array domains = () ein.

Erstellen Sie zunächst die Dateien und Verzeichnisse, falls diese noch nicht vorhanden sind

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

Die Datei spfs.txt enthält alle SPF-Einträge, die Sie zu Ihren DNS-Einträgen für jede Domain hinzufügen müssen.

HINWEIS: Nicht mehrmals ausführen. Es wird nicht geprüft, ob bereits eine Domäne vorhanden ist. Das Skript muss auch als root ausgeführt werden.

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

Dieses Skript automatisiert den Teil nach "Fertig! Der Server ist bereit, mit DKIM zu arbeiten".

Um diesen Prozess ein wenig zu automatisieren, habe ich dieses Bash-Skript erstellt. Fügen Sie einfach eine Domain wie 'example.com' pro Zeile in das Array domains = () ein.

Dieses Skript erstellt die Dateien für Sie und prüft, ob sich bereits eine Zeile in der Datei befindet

Die Datei "spfs.txt" wird bei jeder Ausführung entfernt und neu erstellt. Vor dem Anhängen wird die zweite Zeile der Datei "default.txt" mit der Datei "spfs.txt" verglichen

Sie müssen Ihre Server ipv4 und ipv6 (falls vorhanden) in die bereitgestellten Variablen einfügen. Es wird geprüft, ob sie nicht leer sind

Dank der hinzugefügten Prüfungen können Sie diese Datei mehrmals ausführen.

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