Saltar al contenido

Usando DKIM en mi servidor para múltiples dominios (sitios web)

Posterior a investigar con expertos en el tema, programadores de diversas ramas y profesores hemos dado con la respuesta al problema y la compartimos en esta publicación.

Solución:

¡Bien! Descubrí esto en la publicación mencionada en la pregunta. Hice una especie de mezcla entre la respuesta en sí y los enlaces proporcionados en ella. Especialmente el cuarto enlace es el que utilicé.

Entonces la cosa es así. Suponga que tiene un servidor o VPS y hace que uno de sus dominios sea el dominio principal y se use como el nombre del servidor (en mi ejemplo: midominio.com).

Entonces, en primer lugar, cambiaremos a root para facilitar las cosas, pero puede omitir este paso y usar sudo antes de cada comando.

sudo su

Ahora, instalamos OpenDKIM:

apt-get install opendkim opendkim-tools

Arreglemos el archivo de configuración. Estamos abriendo /etc/opendkim.conf para editar. Yo uso nano, pero es lo mismo con otros editores.

nano /etc/opendkim.conf

Una vez abierto, haz que se vea así. Si se siente cómodo, puede cambiar algunas opciones, pero el Domain, KeyFile y Selector debe quedar comentado.

# 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:[email protected]
#EOF

A continuación, creamos algunas de las carpetas y archivos que contendrán información sobre lo que debe usar y procesar OpenDKIM. Por ahora, el TrustedHosts expediente. Lo creamos y editamos:

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

Debemos poner en este archivo una lista de direcciones confiables: localhost y 127.0.0.1, y su nombre de servidor e IP:

127.0.0.1
localhost
192.99.34.121
mydomain.com

Ahora editamos el archivo de configuración de OpenDKIM.

nano /etc/default/opendkim

Y agregue estas líneas al final del archivo. Le dirán a OpenDKIM en qué puerto debe esperar las solicitudes de firma:

SOCKET="inet:[email protected]"

Abrimos el archivo de configuración de Postfix.

nano /etc/postfix/main.cf

Y agregue estas líneas al final del archivo. Le dirán a Postfix que debe enviar correos electrónicos para que los firme y dónde.

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

Si no está agregando dominios en este momento, puede reiniciar todo, para que la configuración surta efecto.

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

¡Hecho! El servidor está listo para trabajar con DKIM. Ahora, debe agregar sus dominios a este sistema. El siguiente proceso es el mismo para todos los dominios que desea agregar. Usaré otherdomain.com para el ejemplo, lo reemplazaré con el suyo.

Recuerda que yo era root de antes, pero si no lo eres, corre sudo su o preceda sus comandos con la palabra clave sudo.

sudo su

Primero, creamos un directorio para nuestro dominio y entramos en él:

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

Ahora generamos un key para el dominio:

opendkim-genkey -r -d otherdomain.com

Le damos al usuario de OpenDKIM la propiedad del archivo recién creado:

chown opendkim:opendkim default.private

Y abrimos el KeyTable archivo para agregar nuestro nuevo key para nuestro nuevo dominio:

nano /etc/opendkim/KeyTable

Lo agregamos al final del archivo (después de todos los demás dominios que podamos tener aquí):

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

Abrimos el SigningTable expediente.

nano /etc/opendkim/SigningTable

Y agregue al final del archivo (nuevamente, tendremos una línea para cada dominio):

otherdomain.com default._domainkey.otherdomain.com

Esta SigningTable enumera todos los correos que se firman. Con solo agregar un nombre de dominio, se firmarán todos los correos de ese dominio.

No estoy seguro de la necesidad de dar el siguiente paso, pero lo hice, por si acaso … Abrimos el TrustedHosts expediente.

nano /etc/opendkim/TrustedHosts

Y agregue al final del archivo:

otherdomain.com

Una última cosa: mostramos el contenido del archivo. /etc/opendkim/keys/otherdomain.com/default.txt.

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

Y agregue la información entre las comillas a un TXT registro en la Zona DNS del dominio, y también debemos usar default._domainkey como el nombre del registro. NOTA: “entre las comillas” es el texto que comienza con “v=DKIM1;k=rsa; p=WIGfM...“.

Si terminamos de agregar dominios (a esta altura), reiniciamos todo para aplicar los cambios.

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

¡Hecho!

Este script automatiza la parte después de “¡Listo! El servidor está listo para trabajar con DKIM”.

Para ayudar a automatizar un poco este proceso, creé este script bash. Simplemente agregue un ‘dominio.com’ por línea dentro de los dominios = () array.

Primero cree los archivos y directorios si aún no existen

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

El archivo spfs.txt contendrá todos los registros spf que necesita agregar a sus registros DNS para cada dominio.

NOTA: no se ejecute más de una vez, no comprueba si ya existe un dominio. El script también debe ejecutarse 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 la parte después de “¡Listo! El servidor está listo para trabajar con DKIM”.

Para ayudar a automatizar un poco este proceso, creé este script bash. Simplemente agregue un dominio como ‘ejemplo.com’ por línea dentro de los dominios = () array.

Este script crea los archivos por usted y comprueba si ya hay una línea en el archivo.

Spfs.txt se elimina y se vuelve a crear cada vez que se ejecuta y comprueba la segunda línea de default.txt con spfs.txt antes de agregar

Debe colocar sus servidores ipv4 e ipv6 (si los tiene) en las variables provistas. Comprueba si no están vacíos

puede ejecutar este archivo varias veces gracias a las comprobaciones agregadas.

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

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *