Utilizzo di DKIM nel mio server per più domini (siti Web)

Ho letto il tutorial pubblicato da MountainX ( Setup DKIM (DomainKeys) per Ubuntu, Postfix e Mailman ), ma non riesco a capire come applicare questi passaggi se voglio ospitare e inviare e-mail per diversi domini. Qualcuno ha un indizio?

Buono! L'ho capito dal post menzionato nella domanda. Ho creato una sorta di mix tra la risposta stessa e i link forniti in essa. Specialmente il quarto link è quello che ho usato.

Quindi la cosa va così. Supponiamo che tu abbia un server o VPS e che uno dei tuoi domini sia il dominio principale e venga utilizzato come nome del server (nel mio esempio: mydomain.com).

Quindi, prima di tutto, cambieremo in root per semplificare le cose, ma puoi saltare questo passaggio e usarlo sudoprima di ogni comando.

sudo su

Ora installiamo OpenDKIM:

apt-get install opendkim opendkim-tools

Ripariamo il file di configurazione. Stiamo aprendo /etc/opendkim.confper la modifica. Uso nano, ma è lo stesso con altri editor.

nano /etc/opendkim.conf

Una volta aperto, fallo apparire così. Se ti senti a tuo agio, puoi cambiare alcune opzioni, ma il Domain, KeyFilee Selectordeve rimanere commentato.

# 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

Successivamente, creiamo alcune delle cartelle e dei file che conterranno informazioni su cosa dovrebbe usare ed elaborare OpenDKIM. Per ora, il TrustedHostsfile. Lo creiamo e lo modifichiamo:

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

Dobbiamo inserire in questo file un elenco di indirizzi attendibili: localhost e 127.0.0.1, il nome del server e l'IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Ora modifichiamo il file di configurazione di OpenDKIM.

nano /etc/default/opendkim

E aggiungi queste righe alla fine del file. Diranno a OpenDKIM in quale porta dovrebbe aspettarsi le richieste di firma:

SOCKET="inet:8891@localhost"

Apriamo il file di configurazione di Postfix.

nano /etc/postfix/main.cf

E aggiungi queste righe alla fine del file. Diranno a Postfix che dovrebbe inviare e-mail da firmare e dove.

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

Se non stai aggiungendo domini in questo momento, puoi riavviare tutto, quindi la configurazione diventa effettiva.

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

Fatto! Il server è pronto per funzionare con DKIM. Ora devi aggiungere i tuoi domini a questo sistema. Il seguente processo è lo stesso per tutti i domini che si desidera aggiungere. Userò otherdomain.com per l'esempio, lo sostituirò con il tuo.

Ricorda che ero root da prima, ma se non lo sei, esegui sudo suo precedi i tuoi comandi con la parola chiave sudo.

sudo su

Innanzitutto, creiamo una directory per il nostro dominio e andiamo al suo interno:

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

Ora generiamo una chiave per il dominio:

opendkim-genkey -r -d otherdomain.com

Diamo all'utente OpenDKIM la proprietà del file appena creato:

chown opendkim:opendkim default.private

E apriamo il KeyTablefile per aggiungere la nostra nuova chiave per il nostro nuovo dominio:

nano /etc/opendkim/KeyTable

Lo aggiungiamo alla fine del file (dopo tutti gli altri domini che potremmo avere qui):

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

Apriamo il SigningTablefile.

nano /etc/opendkim/SigningTable

E aggiungi alla fine del file (di nuovo, avremo una riga per ogni dominio):

otherdomain.com default._domainkey.otherdomain.com

Questa tabella di firma elenca tutte le mail che vengono firmate. Solo aggiungendo un nome di dominio, tutte le mail di quel dominio verranno firmate.

Non sono sicuro della necessità di fare il passo successivo, ma l'ho appena fatto, nel caso ... Apriamo il TrustedHostsfile.

nano /etc/opendkim/TrustedHosts

E aggiungi alla fine del file:

otherdomain.com

Un'ultima cosa: mostriamo il contenuto del file /etc/opendkim/keys/otherdomain.com/default.txt.

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

E aggiungi le informazioni tra virgolette a un TXTrecord nella zona DNS del dominio e dobbiamo anche usare default._domainkeycome nome del record. NOTA: "tra virgolette" è il testo che inizia con " v=DKIM1;k=rsa; p=WIGfM...".

Se abbiamo finito di aggiungere domini (ormai), riavviamo tutto per applicare le modifiche.

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

Fatto!

Questo script automatizza la parte dopo "Fine! Il server è pronto per funzionare con DKIM"

Per aiutare ad automatizzare un po 'questo processo, ho creato questo script bash. Basta aggiungere un 'dominio.com' per riga all'interno dell'array domains = ().

Innanzitutto creare i file e le directory se non esistono già

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

Il file spfs.txt conterrà tutti i record spf che è necessario aggiungere ai record DNS per ciascun dominio.

NOTA: non eseguire più di una volta, non controlla se esiste già un dominio. Lo script deve anche essere eseguito come 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

Questo script automatizza la parte dopo "Fine! Il server è pronto per funzionare con DKIM"

Per aiutare ad automatizzare un po 'questo processo, ho creato questo script bash. Basta aggiungere un dominio come 'esempio.com' per riga all'interno dell'array domains = ().

Questo script crea i file per te e verifica se nel file è già presente una riga

Spfs.txt viene rimosso e ricreato ogni volta che viene eseguito e verifica la seconda riga di default.txt rispetto a spfs.txt prima di aggiungere

È necessario posizionare i server ipv4 e ipv6 (se presenti) nelle variabili fornite. Controlla se non sono vuoti

puoi eseguire questo file più volte grazie ai controlli aggiunti.

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