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

Question

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

    

Answer 1

Bom! Eu percebi 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 torne um de seus domínios o domínio principal e seja usado como o nome do servidor (no meu exemplo: mydomain.com).

Primeiramente, mudaremos para o root para facilitar as coisas, mas você pode pular esta etapa e usar sudo antes 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.conf para edição. Eu uso nano, mas é o mesmo com outro editor.

nano /etc/opendkim.conf

Uma vez aberto, faça com que seja assim. Se você se sentir à vontade, poderá alterar algumas opções, mas os Domain , KeyFile e Selector devem permanecer comentados.

# 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 pastas e arquivos que conterão informações sobre o que o OpenDKIM deve usar e processar. Por enquanto, o arquivo TrustedHosts . Nós criamos e editamos:

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

Devemos colocar neste arquivo uma lista de endereços confiáveis: localhost e 127.0.0.1, e seu nome de servidor e 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

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

Adicione essas linhas ao final do arquivo. Eles vão dizer ao Postfix que ele deve enviar e-mails para assinar e onde.

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

Se você não está adicionando domínios agora, pode reiniciar tudo, portanto, a configuração entrará 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 o 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. Vou usar otherdomain.com para o exemplo, substitua-o pelo seu.

Lembre-se de que eu era root de antes, mas se você não é, execute sudo su ou preceda seus comandos com a palavra-chave sudo .

sudo su

Primeiro, criamos um diretório para 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 à propriedade do usuário do OpenDKIM o arquivo recém-criado:

chown opendkim:opendkim default.private

E abrimos o arquivo KeyTable para adicionar nossa nova chave ao novo domínio:

nano /etc/opendkim/KeyTable

Adicionamos no final do arquivo (depois de todos os outros domínios que podemos ter aqui):

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

Abrimos o arquivo SigningTable .

nano /etc/opendkim/SigningTable

E anexe no final do arquivo (mais uma vez, teremos uma linha para cada domínio):

otherdomain.com default._domainkey.otherdomain.com

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

Eu não tenho certeza da necessidade de fazer o próximo passo, mas eu apenas fiz isso, apenas no caso ... Abrimos o arquivo TrustedHosts .

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

Adicione as informações entre as aspas a um registro TXT na zona DNS do domínio e também devemos usar default._domainkey como o nome do registro. NOTA: "entre as 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!

    

Answer 2

Este script automatiza a parte depois de "Concluído! O servidor está pronto para trabalhar com o DKIM"

Para ajudar a automatizar este processo, criei este pequeno script. 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, ele não verifica se um domínio já existe. 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

    

Answer 3

Este script automatiza a parte depois de "Concluído! O servidor está pronto para trabalhar com o DKIM"

Para ajudar a automatizar este processo, criei este pequeno script. 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

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 você 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