Usando DKIM no meu servidor para vários domínios (sites)

Eu li o tutorial publicado pelo MountainX ( Setup DKIM (DomainKeys) para Ubuntu, Postfix e Mailman ), mas não consigo descobrir como aplicar essas etapas se quiser hospedar e enviar emails para vários domínios. Alguém tem uma pista?

Boa! Eu descobri isso no post mencionado na pergunta. Eu fiz uma espécie de mistura entre a resposta em si e os links fornecidos nela. Especialmente o quarto link é o que eu usei.

Então a coisa é assim. Suponha que você tenha um servidor ou VPS e faça com que um de seus domínios seja o domínio principal e seja usado como o nome do servidor (no meu exemplo: meudominio.com).

Portanto, antes de tudo, mudaremos para root para facilitar as coisas, mas você pode pular esta etapa e usar sudoantes de cada comando.

sudo su

Agora, instalamos o OpenDKIM:

apt-get install opendkim opendkim-tools

Vamos consertar o arquivo de configuração. Estamos abrindo /etc/opendkim.confpara edição. Eu uso o nano, mas é o mesmo com outro editor.

nano /etc/opendkim.conf

Depois de aberto, faça com que fique assim. Se você se sentir confortável, poderá alterar algumas opções, mas a Domain, KeyFilee Selectordeve permanecer comentada.

# 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

Em seguida, criamos algumas das pastas e arquivos que conterão informações sobre o que o OpenDKIM deve usar e processar. Por enquanto, o TrustedHostsarquivo Nós o criamos e editamos:

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

Devemos colocar nesse arquivo uma lista de endereços confiáveis: localhost e 127.0.0.1, e o nome do servidor e o IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Agora editamos o arquivo de configuração do OpenDKIM.

nano /etc/default/opendkim

E adicione essas linhas no final do arquivo. Eles dirão ao OpenDKIM em qual porta ele deve esperar solicitações de assinatura:

SOCKET="inet:8891@localhost"

Abrimos o arquivo de configuração do Postfix.

nano /etc/postfix/main.cf

E adicione essas linhas ao final do arquivo. Eles dizem ao Postfix que ele deve enviar e-mails para assinar e para onde.

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

Se você não estiver adicionando domínios no momento, poderá reiniciar tudo, para que a configuração entre em vigor.

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

Feito! O servidor está pronto para trabalhar com DKIM. Agora, você precisa adicionar seus domínios a este sistema. O processo a seguir é o mesmo para todos os domínios que você deseja adicionar. Usarei otherdomain.com como exemplo, substitua-o pelo seu.

Lembre-se de que eu era root de antes, mas se não estiver, execute sudo suou preceda seus comandos com a palavra-chave sudo.

sudo su

Primeiro, criamos um diretório para o nosso domínio e entramos nele:

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

Agora geramos uma chave para o domínio:

opendkim-genkey -r -d otherdomain.com

Damos ao usuário OpenDKIM a propriedade do arquivo recém-criado:

chown opendkim:opendkim default.private

E abrimos o KeyTablearquivo para adicionar nossa nova chave ao nosso novo domínio:

nano /etc/opendkim/KeyTable

Nós o adicionamos ao final do arquivo (depois de todos os outros domínios que possamos ter aqui):

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

Abrimos o SigningTablearquivo.

nano /etc/opendkim/SigningTable

E acrescente no final do arquivo (novamente, teremos uma linha para cada domínio):

otherdomain.com default._domainkey.otherdomain.com

Esta tabela de assinaturas lista todos os emails assinados. Apenas adicionando um nome de domínio, todos os e-mails desse domínio serão assinados.

Não tenho certeza da necessidade de executar o próximo passo, mas apenas o fiz, apenas no caso ... Abrimos o TrustedHostsarquivo.

nano /etc/opendkim/TrustedHosts

E adicione no final do arquivo:

otherdomain.com

Uma última coisa: mostramos o conteúdo do arquivo /etc/opendkim/keys/otherdomain.com/default.txt.

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

E adicione as informações entre as aspas a um TXTregistro na zona DNS do domínio, e também devemos usar default._domainkeycomo o nome do registro. NOTA: "entre aspas" é o texto que começa com " v=DKIM1;k=rsa; p=WIGfM...".

Se terminarmos de adicionar domínios (até agora), reiniciaremos tudo para aplicar as alterações.

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

Feito!

Este script automatiza a parte após "Concluído! O servidor está pronto para trabalhar com DKIM"

Para ajudar a automatizar um pouco esse processo, criei esse script bash. Basta adicionar um 'domain.com' por linha dentro da matriz domains = ().

Primeiro crie os arquivos e diretórios se eles ainda não existirem

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

O arquivo spfs.txt conterá todos os registros spf que você precisa adicionar aos seus registros DNS para cada domínio.

NOTA: não execute mais de uma vez, não verifica se já existe um domínio. O script também precisa ser executado como 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

Este script automatiza a parte após "Concluído! O servidor está pronto para trabalhar com DKIM"

Para ajudar a automatizar um pouco esse processo, criei esse script bash. Basta adicionar um domínio como 'example.com' por linha dentro da matriz domains = ().

Este script cria os arquivos para você e verifica se uma linha já está no arquivo

O Spfs.txt é removido e recriado toda vez que é executado e verifica a segunda linha do default.txt em relação ao spfs.txt antes de anexar

Você deve colocar seus servidores ipv4 e ipv6 (se os tiver) nas variáveis ​​fornecidas. Ele verifica se eles não estão vazios

você pode executar este arquivo várias vezes, graças às verificações adicionadas.

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