Używanie DKIM na moim serwerze dla wielu domen (stron internetowych)

Przeczytałem samouczek opublikowany przez MountainX ( Konfiguracja DKIM (DomainKeys) dla Ubuntu, Postfix i Mailman ), ale nie mogę wymyślić, jak zastosować te kroki, jeśli chcę hostować i wysyłać wiadomości e-mail dla kilku domen. Czy ktoś ma jakiś pomysł?

Dobry! Zrozumiałem to na podstawie wpisu wymienionego w pytaniu. Zrobiłem swego rodzaju mieszankę między samą odpowiedzią a linkami w niej zawartymi. Zwłaszcza czwarty link to ten, którego użyłem.

Więc tak to wygląda. Załóżmy, że masz serwer lub VPS i ustaw jedną z domen jako domenę główną i użyj jej jako nazwy serwera (w moim przykładzie: mojadomena.com).

Przede wszystkim zmienimy na rootowanie, aby ułatwić, ale możesz pominąć ten krok i użyć sudoprzed każdym poleceniem.

sudo su

Teraz instalujemy OpenDKIM:

apt-get install opendkim opendkim-tools

Naprawmy plik konfiguracyjny. Otwieramy /etc/opendkim.confdo edycji. Używam nano, ale to samo z innym edytorem.

nano /etc/opendkim.conf

Po otwarciu wyglądaj tak. Jeśli czujesz się komfortowo, można zmienić niektóre opcje, ale Domain, KeyFilei Selectormusi pozostać skomentował.

# 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

Następnie tworzymy niektóre foldery i pliki, które będą zawierać informacje o tym, czego powinien używać i przetwarzać OpenDKIM. Na razie TrustedHostsplik. Tworzymy i edytujemy:

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

Musimy umieścić w tym pliku listę zaufanych adresów: localhost i 127.0.0.1, a także nazwę twojego serwera i adres IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Teraz edytujemy plik konfiguracyjny OpenDKIM.

nano /etc/default/opendkim

I dodaj te linie na końcu pliku. Poinformują OpenDKIM, w którym porcie powinien oczekiwać żądań podpisania:

SOCKET="inet:8891@localhost"

Otwieramy plik konfiguracyjny Postfix.

nano /etc/postfix/main.cf

I dodaj te linie na końcu pliku. Poinformują Postfix, że powinien wysłać e-maile do podpisu i gdzie.

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

Jeśli nie dodajesz teraz domen, możesz zrestartować wszystko, więc konfiguracja zostanie zastosowana.

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

Gotowy! Serwer jest gotowy do pracy z DKIM. Teraz musisz dodać swoje domeny do tego systemu. Poniższy proces jest taki sam dla wszystkich domen, które chcesz dodać. Na przykład użyję otherdomain.com, zastąpię ją własną.

Pamiętaj, że byłem rootem wcześniej, ale jeśli nie jesteś, uruchom sudo sulub poprzedzaj polecenia słowem kluczowym sudo.

sudo su

Najpierw tworzymy katalog dla naszej domeny i wchodzimy do niej:

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

Teraz generujemy klucz dla domeny:

opendkim-genkey -r -d otherdomain.com

Dajemy użytkownikowi OpenDKIM prawo własności do nowo utworzonego pliku:

chown opendkim:opendkim default.private

I otwieramy KeyTableplik, aby dodać nasz nowy klucz do naszej nowej domeny:

nano /etc/opendkim/KeyTable

Dodajemy go na końcu pliku (po wszystkich innych domenach, które możemy tutaj mieć):

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

Otwieramy SigningTableplik.

nano /etc/opendkim/SigningTable

I dołącz na końcu pliku (ponownie, będziemy mieli jeden wiersz dla każdej domeny):

otherdomain.com default._domainkey.otherdomain.com

Ta tablica podpisów zawiera listę wszystkich podpisanych wiadomości e-mail. Po dodaniu nazwy domeny wszystkie wiadomości e-mail z tej domeny zostaną podpisane.

Nie jestem pewien konieczności wykonania następnego kroku, ale właśnie to zrobiłem, na wszelki wypadek ... Otwieramy TrustedHostsplik.

nano /etc/opendkim/TrustedHosts

I dodaj na końcu pliku:

otherdomain.com

I ostatnia rzecz: pokazujemy zawartość pliku /etc/opendkim/keys/otherdomain.com/default.txt.

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

I dodaj informacje między cudzysłowami do TXTrekordu w strefie DNS domeny, a my musimy również użyć default._domainkeyjako nazwy rekordu. UWAGA: „między cudzysłowami” to tekst rozpoczynający się od „ v=DKIM1;k=rsa; p=WIGfM...”.

Po zakończeniu dodawania domen (do tej pory) restartujemy wszystko, aby zastosować zmiany.

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

Gotowy!

Ten skrypt automatyzuje część po „Gotowe! Serwer jest gotowy do pracy z DKIM”

Aby trochę zautomatyzować ten proces, stworzyłem ten skrypt bash. Wystarczy dodać jedną „domain.com” w wierszu wewnątrz tablicy domains = ().

Najpierw utwórz pliki i katalogi, jeśli jeszcze nie istnieją

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

Plik spfs.txt będzie zawierał wszystkie rekordy SPF, które należy dodać do rekordów DNS dla każdej domeny.

UWAGA: nie uruchamiaj więcej niż raz, nie sprawdza, czy domena już istnieje. Skrypt musi być również uruchamiany jako 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

Ten skrypt automatyzuje część po „Gotowe! Serwer jest gotowy do pracy z DKIM”

Aby trochę zautomatyzować ten proces, stworzyłem ten skrypt bash. Wystarczy dodać jedną domenę, np. „Example.com” do wiersza w tablicy domains = ().

Ten skrypt tworzy dla Ciebie pliki i sprawdza, czy wiersz jest już w pliku

Plik Spfs.txt jest usuwany i ponownie tworzony za każdym razem, gdy jest uruchamiany, i sprawdza drugą linię pliku default.txt względem pliku spfs.txt przed dołączeniem

Musisz umieścić swoje serwery ipv4 i ipv6 (jeśli je masz) w podanych zmiennych. Sprawdza, czy nie są puste

możesz dodać ten plik wiele razy dzięki dodanym kontrolom.

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