Herramientas de usuario

Herramientas del sitio


octaviotron:postfix

Servidor de Correos POSTFIX + COURIER + MYSQL + ROUNDCUBE con plugin para cambiar contraseñas

Esta documentación está basada en un tutorial de HowtoForge (leer), comprende la configuración y administración de un servidor de correos con las siguientes características:

  • Sistema Operativo Debian GNU/Linux SQUEEZE (sin componentes privativos, por supuesto)
  • Servidor MTA POSTFIX
    • Soporte para Dominios y Usuarios virtuales
    • Soporte para límites de almacenamiento (QUOTAS)
    • Restricciones de usuarios locales y globales
    • Restricción de SPAM usando listas negras, grises y blancas
    • Restricción o Permisibilidad específica para IPs, Dominios o Buzones
  • Servidor MUA COURIER para manejo de POP + IMAP
  • WEBMAIL con ROUNDCUBE
    • Soporte para cambio de contraseñas por los usuarios
  • Reglas UCE (antispam) básicas, basadas en estándares RFC.

Todos los dominios, usuarios, filtros y configuraciones relacionadas se almacenarán en una base de datos MySQL

En esta documentación, se usarán los siguientes valores de ejemplo:

  • Nombre del servidor (FQDN): servidor.dominio.tal
  • IP pública del servidor: 192.168.0.100

Debe colocar los valores correspondientes para su configuración.

Configuración del Sistema Operativo

Verificamos que en el archivo /etc/hostmane esté el nombre de la máquina

/etc/hostname

servidor.dominio.tal

y verificamos que /etc/hosts tenga los datos apropiados para resolver localmente nuestras direcciones IP:

/etc/hosts

127.0.0.1 localhost.localdomain localhost
192.168.0.100 servidor.dominio.tal servidor

Si el servidor tiene dirección IPV6 es importante agregar esto a ese mismo archivo

::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts

Es importante, por tratarse de SQUEEZE que /bin/sh sea un link simbólico a /bin/bash

dpkg-reconfigure dash

Se realizará la siguiente pregunta:

Use dash as the default system shell (/bin/sh)? <-- No

Instalación del POSTFIX

Instalamos los paquetes necesarios:

aptitude update
aptitude install postfix postfix-mysql postfix-doc mysql-client mysql-server courier-authdaemon \
courier-authlib-mysql courier-pop courier-pop-ssl courier-imap courier-imap-ssl libsasl2-2 \
libsasl2-modules libsasl2-modules-sql sasl2-bin libpam-mysql openssl phpmyadmin apache2 \
libapache2-mod-php5 php5 php5-mysql libpam-smbpass

Se responden así a las preguntas siquientes que pudiera hacerle el proceso de instalación:

General type of mail configuration: <-- Internet Site
System mail name: <-- servidor.dominio.tal
New password for the MySQL "root" user: <-- (acá la clave de root que usará MYSQL)
Repeat password for the MySQL "root" user: <-- (se repite la clave)
Create directories for web-based administration? <-- No
SSL certificate required <-- Ok
Workgroup/Domain Name: <-- WORKGROUP
Web server to reconfigure automatically: <-- apache2
Configure database for phpmyadmin with dbconfig-common? <-- No

Aplicando parche para soporte de límites (QUOTAS) al POSTFIX

Debemos obtener las fuentes del POSTFIX (afortunadamente, usamos Software Libre), luego aplicarles el parche para QUOTAS, construir el nuevo paquete .deb de POSTFIX e instalarlo en nuestro sistema:

apt-get build-dep postfix
cd /usr/src
apt-get source postfix

Esto último comando necesitará tener en los repositorios (/etc/apt/sources.list) las entradas para descargarse las fuentes de los programas.

Hay que asegurarse que se esté usando la misma versión de los parches que nos descargaremos. En este ejemplo se usará la versión 2.7.1 de POSTFIX. Para verificar esto, podemos hacer así:

postconf -d | grep mail_version

y la salida deberá contener easta línea:

mail_version = 2.7.1

Entonces nos descargamos las fuentes y les aplicamos el parche:

wget http://vda.sourceforge.net/VDA/postfix-vda-2.7.1.patch
cd postfix-2.7.1
patch -p1 < ../postfix-vda-2.7.1.patch
dpkg-buildpackage

Esto creará en el directorio superior (../) los paquetes .deb creados:

cd ..
ls -l

Veremos los paquetes creados:

drwxr-xr-x 19 root root 4,0K abr 13 20:03 postfix-2.7.1
-rw-r--r--  1 root root 3,8K abr 13 20:03 postfix_2.7.1-1+squeeze1_amd64.changes
-rw-r--r--  1 root root 1,4M abr 13 20:03 postfix_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root 230K abr 13 20:02 postfix_2.7.1-1+squeeze1.diff.gz
-rw-r--r--  1 root root 1,2K abr 13 20:02 postfix_2.7.1-1+squeeze1.dsc
-rw-r--r--  1 root root 3,3M jun 21  2010 postfix_2.7.1.orig.tar.gz
-rw-r--r--  1 root root  42K abr 13 20:03 postfix-cdb_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root 143K abr 13 20:03 postfix-dev_2.7.1-1+squeeze1_all.deb
-rw-r--r--  1 root root 979K abr 13 20:03 postfix-doc_2.7.1-1+squeeze1_all.deb
-rw-r--r--  1 root root  50K abr 13 20:03 postfix-ldap_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root  44K abr 13 20:03 postfix-mysql_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root  44K abr 13 20:03 postfix-pcre_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root  44K abr 13 20:03 postfix-pgsql_2.7.1-1+squeeze1_amd64.deb
-rw-r--r--  1 root root  59K nov  5  2010 postfix-vda-2.7.1.patch

De allí instalaremos los paquetes “postfix” y “postfix-mysql”. En este caso la arquitectura es “amd64” puede variar en otros casos:

dpkg -i postfix_2.7.1-1+squeeze1_amd64.deb postfix-mysql_2.7.1-1+squeeze1_amd64.deb

Luego es necesario retener (hold) las actualizaciones automáticas de POSTFIX mediante APTITUDE ya que intentará actualizar el paquete recién instalado y se perderán los binarios parcheados. En caso de haber alguna actualización de seguridad de POSTFIX será necesario repetir todos los pasos de esta sección:

aptitude hold postfix
aptitude hold postfix-mysql

Si se usa apt-get para administrar el sistema deben entonces retenerse (hold) así:

echo "postfix install" | dpkg --set-selections
echo "postfix-mysql install" | dpkg --set-selections

Configurando POSTFIX

No usaremos la configuración por defecto que ha quedado en /etc/postfix/main.cf así que haremos nuestro propio archivo de configuración:

mv /etc/postfix/main.cf /etc/postfix/orig_main.cf
touch /etc/postfix/main.cf
vim /etc/postfix/main.cf

Editando ese archivo (acá con VIM, se puede usar cualquier editor de texto) se colocará el siguiente contenido, recuerde colocar los datos apropiados en “myhostname”:

/etc/postfix/main.cf

# Configuraciones GENERALES
myhostname = servidor.dominio.tal
myorigin = $myhostname
mydestination = $myhostname, localhost, localhost.localdomain
alias_maps = hash:/etc/aliases
alias_database = hash:/etc/aliases
transport_maps = proxy:mysql:/etc/postfix/mysql-virtual_transports.cf
smtpd_banner = $myhostname ESMTP $mail_name (Debian/GNU)
mailbox_command = procmail -a "$EXTENSION"
mailbox_size_limit = 0
biff = no
append_dot_mydomain = no
relayhost = 
mynetworks = 127.0.0.0/8
recipient_delimiter = +
inet_interfaces = all
smtpd_sasl_auth_enable = yes

# Parámetros para dominios VIRTUALES
virtual_alias_domains = 
virtual_alias_maps = proxy:mysql:/etc/postfix/mysql-virtual_forwardings.cf, mysql:/etc/postfix/mysql-virtual_email2email.cf
virtual_mailbox_domains = proxy:mysql:/etc/postfix/mysql-virtual_domains.cf
virtual_mailbox_maps = proxy:mysql:/etc/postfix/mysql-virtual_mailboxes.cf
virtual_mailbox_base = /home/vmail
virtual_uid_maps = static:5000
virtual_gid_maps = static:5000
virtual_create_maildirsize = yes
virtual_maildir_extended = yes
virtual_mailbox_limit_maps = proxy:mysql:/etc/postfix/mysql-virtual_mailbox_limit_maps.cf
virtual_mailbox_limit_override = yes
virtual_maildir_limit_message = "El usuario que está tratando de alcanzar tiene su buzón lleno."
virtual_overquota_bounce = yes 

# TLS
smtp_use_tls = yes
smtp_tls_CAfile = /etc/postfix/tls/root.crt
smtp_tls_cert_file = /etc/postfix/tls/server.pem
smtp_tls_key_file = /etc/postfix/tls/key.pem
smtp_tls_session_cache_database = btree:${data_directory}/smtp_tls_session_cache
smtp_tls_loglevel = 1

smtpd_use_tls = yes
smtpd_tls_CAfile = /etc/postfix/tls/root.crt
smtpd_tls_cert_file = /etc/postfix/tls/server.pem
smtpd_tls_key_file = /etc/postfix/tls/key.pem
smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_tls_session_cache
smtpd_tls_loglevel = 1
smtpd_tls_ask_ccert = yes
smtpd_tls_received_header = yes

# Reglas de acceso, restricciones, filtros y autenticaciones

smtpd_client_restrictions =
 reject_unknown_reverse_client_hostname
 reject_unauth_pipelining
 check_client_access mysql:/etc/postfix/mysql-client.cf
 permit_mynetworks
 
smtpd_recipient_restrictions =
 permit_sasl_authenticated
 reject_non_fqdn_recipient
 reject_unauth_destination
 reject_unauth_pipelining
 reject_invalid_hostname
 reject_unknown_recipient_domain
 check_recipient_access mysql:/etc/postfix/mysql-recipipent.cf
 reject_rbl_client blackholes.mail-abuse.org
 reject_rbl_client cbl.abuseat.org
 reject_rbl_client dul.dnsbl.sorbs.net
 #check_recipient_access mysql:/etc/postfix/mysql-localonly-receive.cf  #Opcional

smtpd_sender_restrictions =
 reject_non_fqdn_sender
 check_sender_access mysql:/etc/postfix/mysql-sender.cf
 #check_sender_access mysql:/etc/postfix/mysql-localonly.cf #Opcional

# OPCIONAL: Configuraciones para los buzones locales  
#smtpd_restriction_classes = local_only
#local_only = check_recipient_access hash:/etc/postfix/local_domains, reject

#    las reglas HELO RESTRICTION pueden bloquear muchos falsos positivos, pues es comun     #
#    encontrar servidores de correo que no se identifiquen plenamente. Se recomienda crear  #
#    una lista blanca que acompañe estas restricciones *antes* de ponerlas en uso.          #
#smtpd_helo_restrictions =
# check_helo_access mysql:/etc/postfix/mysql-helo.cf
# reject_invalid_helo_hostname
# reject_non_fqdn_helo_hostname
# reject_unknown_helo_hostname
# permit_mynetworks
  
maps_rbl_domains =
 blackholes.mail-abuse.org
 cbl.abuseat.org
 dul.dnsbl.sorbs.net

proxy_read_maps = $local_recipient_maps
 $mydestination 
 $virtual_alias_maps 
 $virtual_alias_domains 
 $virtual_mailbox_maps 
 $virtual_mailbox_domains 
 $relay_recipient_maps 
 $relay_domains 
 $canonical_maps 
 $sender_canonical_maps 
 $recipient_canonical_maps 
 $relocated_maps 
 $transport_maps 
 $mynetworks 
 $virtual_mailbox_limit_maps

Ahora creamos el Grupo vmail y le asignamos el GID (group ID) 5000:

groupadd -g 5000 vmail

También el usuario vmail (no será un usuario de sistema), lo agregamos al grupo vmail y le asignamos el UID (user ID) 5000:

useradd -s /usr/sbin/nologin -g vmail -u 5000 vmail -d /home/vmail -m

Soporte para IPV6

En caso de hacer uso de direccionamiento IPV6 en el servidor, es necesario agregar en /etc/postfix/main.cf una de estas opciones:

/etc/postfix/main.cf:

inet_protocols = ipv4       (POR OMISION: se habilita sólo IPv4)
inet_protocols = all        (IPv4 y si está disponible también ipv6)
inet_protocols = ipv4, ipv6 (Habilita los dos protocolos)
inet_protocols = ipv6       (sólo IPv6)

“all” es una buena opcion. La diferencia entre usar “all” y “ipv4,ipv6” es que all no reportará “warning: inet_protocols: IPv6 support is disabled: Address family not supported by protocol” cuando el protocolo no esté presente en el sistema operativo.

Luego declaramos nuestras IPs en “mynetwork” así:

/etc/postfix/main.cf

mynetworks = 127.0.0.0/8 [::1]/128 [fe80::]/10

Si el sistema de correos recibe envíos mediante direccionamiento ipv6 y éste no se encuentra configurado, se generarán errores de “relay access denied”, debido a que se intenta enviar correo desde una dirección que no pertenece a “mynetworks” y por lo tanto no está autorizado el MTA para recibir correo de esa dirección. Hay que agregar acá todas las direcciones (o subred) que esté autorizado a enviar correos desde este servidor.

Información detallada en la documentación sobre ipv6 en POSTFIX (leer)

Creación de la Base de Datos MYSQL

Se crea la base de datos llamada “mail”:

mysqladmin -u root -p create mail

La contraseña que se solicita es la que se suministró en la configuración inicial, al instalar los paquetes.

Entramos en la base de datos creada (con la misma contraseña). Se agregará un nuevo usuario, llamado “mail_admin” con la contraseña “XXXXXXXXXXXXX”:

mysql -u root -p
GRANT SELECT, INSERT, UPDATE, DELETE ON mail.* TO 'mail_admin'@'localhost' IDENTIFIED BY 'XXXXXXXXXXXXX';
GRANT SELECT, INSERT, UPDATE, DELETE ON mail.* TO 'mail_admin'@'localhost.localdomain' IDENTIFIED BY 'XXXXXXXXXXXXX';
FLUSH PRIVILEGES;
USE mail;
CREATE TABLE domains (
  domain varchar(50) NOT NULL, 
  PRIMARY KEY (domain) ) TYPE=MyISAM;
CREATE TABLE forwardings (
  source varchar(80) NOT NULL, 
  destination TEXT NOT NULL, 
  PRIMARY KEY (source) ) TYPE=MyISAM;
CREATE TABLE users ( 
  email varchar(80) NOT NULL, 
  password varchar(20) NOT NULL, 
  quota INT(10) DEFAULT '10485760', 
  local ENUM('0','1') NOT NULL default '0', 
  PRIMARY KEY (email) ) TYPE=MyISAM;
CREATE TABLE transport ( 
  domain varchar(128) NOT NULL default '', 
  transport varchar(128) NOT NULL default '', 
  UNIQUE KEY domain (domain) ) TYPE=MyISAM;
CREATE TABLE filters (
  id int(10) unsigned NOT NULL auto_increment,
  source varchar(128) NOT NULL,
  action varchar(128) NOT NULL,
  type varchar(16) NOT NULL,
  PRIMARY KEY  (`id`) ) TYPE=MyISAM;
quit;

Explicación de las tablas creadas:

  • DOMAINS: en esta tabla se guardan los dominios que serán manejados por el MTA.
    • campo “domain”: guarda el nombre de cada dominio, ejemplo “midominippersonal.org.ve”
  • USERS: en esta tabla se almacenan los usuarios que existen y sus datos de acceso
    • email: es el campo del nombre de usuario. Debe incluir el dominio. Ejemplo: “usuario@dominio.tal”
    • pasword: en este campo se almacenan las claves cifradas. NOTA: deben guardarse con la función ENCRYPT del MySQL.
    • quota: límite de almacenamiento soportado por el buzón. Por defecto 10485760 bytes (10 MB)
    • local: es un booleano (cero o uno) que indica si el usuario puede sólo enviar correos a su dominio o si tiene salida al exterior
  • FORWARDINGS: esta es la tabla donde se almacenan los ALIAS de correos
    • source: buzón a ser redirigido (alias) ejemplo: mi_alias@dominio.tal
    • destination: buzón o grupo de buzones al cual se redirigen los correos enviados a “source”, se pueden separar por comas o por nuevas líneas
  • TRANSPORT: permite reenviar correos de usuarios o dominios a otro servidor
    • domain: fuente que será redirigida, ejemplo: “dominio.cual”
    • transport: destino para el reenvío. ejemplo: smtp:[1.2.3.4]
  • FILTERS: acá van los filtros de listas blancas o listas negras que se necesitan:
    • id: es un campo de autoincremento, usado para futuras implementaciones de escalabilidad
    • source: buzón, dominio o IP al cual se le aplica el filtro
    • action: respuesta enviada por el MTA (OK, REJECT, etc) junto con cualquier texto de explicacion
    • type: acá se almacena el tipo de regla POSTFIX que puede hacer la llamada a este campo (helo, client, sender o recipient)

Creación de los archivos de conexión POSTFIX-MYSQL

Se deben crear los siguientes archivos (con la contraseña apropiada)

Todos los archivos siguientes tienen estas líneas:

user = mail_admin
password = XXXXXXXXXXXXX
dbname = mail
hosts = 127.0.0.1

y a cada uno de los siguientes archivos de configuración se le añaden las líneas pertinentes:

Archivo donde se buscan en MySQL los dominios existentes:

/etc/postfix/mysql-virtual_domains.cf

table = domains
select_field = domain
where_field = domain

Archivo donde se buscan en MySQL los alias y redirecciones hacia los buzones existentes

/etc/postfix/mysql-virtual_forwardings.cf

table = forwardings
select_field = destination
where_field = source

Archivo donde se buscan en MySQL los usuarios (buzones)

/etc/postfix/mysql-virtual_mailboxes.cf

table = users
select_field = email
where_field = email
result_format = %d/%u/

Archivo donde se buscan en MySQL los buzones locales

/etc/postfix/mysql-virtual_email2email.cf

table = users
select_field = email
where_field = email

Archivo donde se buscan en MySQL los servidores MX externos

/etc/postfix/mysql-virtual_transports.cf

table = transport
select_field = transport
where_field = domain

Archivo donde se buscan en MySQL los límites de almacenamiento (QUOTAS)

/etc/postfix/mysql-virtual_mailbox_limit_maps.cf

table = users
select_field = quota
where_field = email

Reglas contra SPAM y UCE

Listas Blancas y Listas Negras

Archivo donde se buscan en MySQL los filtros del smtpd_client_restriction

/etc/postfix/mysql-client.cf

table = filters
select_field = action
where_field = source
additional_conditions = and type = 'client'

Archivo donde se buscan en MySQL los filtros del smtpd_sender_restriction

/etc/postfix/mysql-sender.cf

table = filters
select_field = action
where_field = source
additional_conditions = and type = 'sender'

Archivo donde se buscan en MySQL los filtros en smtpd_recipient_restriction

/etc/postfix/mysql-recipipent.cf

table = filters
select_field = action
where_field = source
additional_conditions = and type = 'recipient'

Toca entonces llenar las tablas con los valores adecuados. Ejemplos de posibles entradas:

"@aim.com", "REJECT spammer", "sender"
"fulanito@fulanito.com", "REJECT dominio invalido", "sender"
"192.168.1.1", "450 REJECT", "client"
"banco@bancotal.com", "REJECT posible phishing", "sender"
"latinmail.com", "450 REJECT", "domain"

Mensajes para Aceptar o Rechazar que se pueden usar

  • Aceptar:
    • OK (solo para dominios, clientes)
    • DUNNO (para senders y recipients)
  • Rechazar:
    • [SMTP CODE] texto
    • REJECT texto
    • DEFER_IF_REJECT (+texto opccional)
    • DEFER_IF_PERMIT (+texto opccional)
    • DISCARD (+texto opccional)
    • DUNNO FILTER transport:destination
    • HOLD (+texto opccional)
    • PREPEND headername: headervalue
    • REDIRECT user@domain
    • WARN

Documentación sobre estos mensajes y sus consecuencias en la Documentación Oficial de POSTFIX

Verificación de Cabeceras y MIME

En e directorio /etc/postfix/check colocaremos estos filtros

mkdir /etc/postfix/check
cd /etc/postfix/check

Creamos los siguientes archivos de configuración:

/etc/postfix/check/mime_check.regexp

/^\s*Content-(Disposition|Type).*name\s*=\s*"?  (.+\.(lnk|asd|hlp|ocx|reg|bat|c[ho]m|cmd|exe|dll|vxd|pif|scr|hta|jse?|sh[mbs]|vb[esx]|ws[fh]|wav|mov|wmf|xl))"?\s*$/ REJECT Tipo de adjunto no permitido. El archivo "$2" tiene extensión "$3"

/etc/postfix/check/headers_check.regexp

/^received:.*xxxxxxxxxxxxxxxx/                           REJECT
/^to:.*@public\.com$/                                    REJECT
/^Subject .*Free Money/                                  REJECT Parecera mentira pero es la regla de "Spam Header #42"
/^content-(type|disposition):.*name[[:space:]]*=.*\.(exe|vbs)/ REJECT No aceptamos adjuntos con la extension: $2
/Make Money/ REJECT
/VIAGRA/ REJECT

Buzones Locales o Públicos (opcional)

Este paso se seguirá sólo si se desean buzones que sólo puedan enviar correos a su propio dominio, sin salida a otros dominios en Internet y buzones con capacidad para sí poder enviar correos a dominios foráneos.

Archivo donde se buscan en MySQL los buzones que sólo pueden enviar correo a dominios locales:

/etc/postfix/mysql-localonly.cf

table = users
select_field = 'local_only'
where_field = email
additional_conditions = AND local = 1

Archivo donde se buscan en MySQL los buzones que sólo pueden recibir correo de los dominios locales

/etc/postfix/mysql-localonly-receive.cf

table = users
select_field = 'permit_mynetworks,reject'
where_field = email
additional_conditions = AND local = 1

Estas dos configuraciones verifican si un usuario (buzón de correos) es local, es decir, que sólo puede enviar correos a determinados dominios o si es global, es decir, que no tiene esta restricción.

Es necesario crear la lista de dominios que son locales. Se puede usar la base de datos también, pero en este caso se guardará en un archivo db ubicado en el directorio de configuración del POSTFIX también y dentro colocamos nuestros dominios sujetos a ser dominios locales:

/etc/postfix/local_domains

dominio.tal
dominio.cual

Para que POSTFIX pueda leer esa lista la transformamos en un archivo db:

cd /etc/postfix
postmap local_domains

Si se verifica el directorio se habrá creado un archivo llamado “local_domains.db” el cual será el archivo que realmente POSTFIX consulte. Cada vez que se haga una modificación a /etc/postfix/local_domains será obligatorio ejecutar “postmap” de nuevo.

en adelante, los usuarios que tengan activado el bit “local” en la base de datos serán sólo usuarios a los cuales se les permite enviar y recibir correos únicamente a los dominios que están en la lista anteriormente definida.

Configuración de las capas de seguridad y autenticación (SSL, TLS, SASLAUTH)

Generación del Certificado

NOTA: en esta página se explica cómo generar certificados públicos con CAcert.org

Creamos el certificado que se usará para cifrar los canales de comunicación:

cd /etc/postfix
openssl req -new -outform PEM -out smtpd.cert -newkey rsa:2048 -nodes -keyout smtpd.key -keyform PEM -days 365 -x509

Es necesario responder las preguntas acorde a los datos de la organización:

Country Name (2 letter code) [AU]: <-- VE
State or Province Name (full name) [Some-State]: <-- Distrito Capital
Locality Name (eg, city) []: <-- Caracas
Organization Name (eg, company) [Internet Widgits Pty Ltd]: <-- Nombre de la Organización
Organizational Unit Name (eg, section) []: <-- Nombre del departamento o unidad administradora
Common Name (eg, YOUR name) []: <-- servidor.dominio.tal
Email Address []: <-- correo@dominio.tal

Y otorgamos los permisos adecuados para ese archivo generado:

chmod o= /etc/postfix/smtpd.key

Esto hará un certificado auto-firmado. Es aconsejable que sea un ente certificador quien emita estas credenciales. Para los efectos del funcionamiento del sistema MTA-MUA esta generación del certificado funcionará.

Configuración de SASLAUTHD

Creamos un directorio en el cual se guardarán los sockets del servicio

mkdir -p /var/spool/postfix/var/run/saslauthd

Y editamos /etc/default/saslauthd para que se inicie efectivamente cuendo se levante el servidio (colocando la variable correspondiente en START) y ajustando las opciones para que lea el directorio que hemos creado y sea allí donde almacene los sockets (en /var/spool/postfix/var/run/saslauthd)

El archivo quedará con estos valores:

/etc/default/saslauthd

START=yes
DESC="SASL Authentication Daemon"
NAME="saslauthd"
MECHANISMS="pam"
MECH_OPTIONS=""
THREADS=5
OPTIONS="-c -m /var/spool/postfix/var/run/saslauthd -r"

Así haremos que SASLAUTHD use PAM para la autenticación. Procedemos a configurar PAM para que así sea:

/etc/pam.d/smtp

auth    required   pam_mysql.so user=mail_admin passwd=XXXXXXXXXXXXX host=127.0.0.1 db=mail table=users usercolumn=email passwdcolumn=password crypt=1
account sufficient pam_mysql.so user=mail_admin passwd=XXXXXXXXXXXXX host=127.0.0.1 db=mail table=users usercolumn=email passwdcolumn=password crypt=1

Creamos la configuración de SASL para POSTFIX en el archivo /etc/postfix/sasl/smtpd.conf

/etc/postfix/sasl/smtpd.conf

pwcheck_method: saslauthd
mech_list: plain login
allow_plaintext: true
auxprop_plugin: mysql
sql_hostnames: 127.0.0.1
sql_user: mail_admin
sql_passwd: XXXXXXXXXXXXX
sql_database: mail
sql_select: select password from users where email = '%u'

Y finalmente agregamos POSTFIX al grupo de SASL

adduser postfix sasl

Para que todo tenga efecto reiniciamos los dos servicios:

/etc/init.d/postfix restart
/etc/init.d/saslauthd restart

Configuración de COURIER para transporte POP e IMAP

Este servicio debe autenticar usando la base de datos MySQL asó que en el archivo /etc/courier/authdaemonrc le indicamos eso, configurando la variable “authmodulelist”, quedando de la siguiente forma:

authmodulelist="authmysql"

Y creamos un nuevo archivo /etc/courier/authmysqlrc:

cat /dev/null > /etc/courier/authmysqlrc
vim /etc/courier/authmysqlrc

Dentro de ese archivo colocamos los datos apropiados:

MYSQL_SERVER localhost
MYSQL_USERNAME mail_admin
MYSQL_PASSWORD XXXXXXXXXXXXX
MYSQL_PORT 0 
MYSQL_DATABASE mail
MYSQL_USER_TABLE users
MYSQL_CRYPT_PWFIELD password
MYSQL_UID_FIELD 5000
MYSQL_GID_FIELD 5000
MYSQL_LOGIN_FIELD email
MYSQL_HOME_FIELD "/home/vmail"
MYSQL_MAILDIR_FIELD CONCAT(SUBSTRING_INDEX(email,'@',-1),'/',SUBSTRING_INDEX(email,'@',1),'/')
MYSQL_QUOTA_FIELD quota

En la instalación de los paquetes se creó un certificado con el nombre de máquina “localhost”.

La salida fue:

Configurando courier-pop-ssl (0.65.0-3) ...
cp: not writing through dangling symlink «/usr/lib/courier/pop3d.pem»
chmod: cannot operate on dangling symlink «/usr/lib/courier/pop3d.pem»
chown: cannot dereference «/usr/lib/courier/pop3d.pem»: No existe el fichero o el directorio
Generating a 1024 bit RSA private key
.....................................++++++
......++++++
writing new private key to '/usr/lib/courier/pop3d.pem'
-----
subject= /C=US/ST=NY/L=New York/O=Courier Mail Server/OU=Automatically-generated POP3 SSL key/CN=localhost/emailAddress=postmaster@exa

Es importante corregir esto y colocarle el FQDN de nuestro servidor (servidor.dominio.tal):

cd /etc/courier
rm -f /etc/courier/imapd.pem
rm -f /etc/courier/pop3d.pem

y se modifican los dos archivos que generen esos certificados:

en el archivo /etc/courier/imapd.cnf debe decir:

CN=servidor.dominio.tal

e igualmente en /etc/courier/pop3d.cnf

CN=servidor.dominio.tal

Pueden ajustarse los demás datos de ser necesario. Luego se generan de nuevo los certificados:

mkimapdcert
mkpop3dcert

y finalmente se reinician los servicios de COURIER:

/etc/init.d/courier-authdaemon restart
/etc/init.d/courier-imap restart
/etc/init.d/courier-imap-ssl restart
/etc/init.d/courier-pop restart
/etc/init.d/courier-pop-ssl restart

Para probar que todo está en orden se corre el siguiente comando:

telnet localhost pop3

Si todo está en orden ese comando realizará una conexión POP3 exitosa. Para salir sólo se escribe “quit”

telnet localhost pop3
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is '^]'.
+OK Hello there.
quit
+OK Better luck next time.
Connection closed by foreign host.

Entonces tenemos que generar los certificados TLS para la condificación y la autenticación:

mkdir /etc/postfix/tls
cd /etc/postfix/tls
touch smtpd.key
chmod 600 smtpd.key
openssl genrsa 1024 > smtpd.key
openssl req -new -key smtpd.key -x509 -days 3650 -out smtpd.crt
openssl req -new -x509 -extensions v3_ca -keyout cakey.pem -out cacert.pem -days 3650
cp smtpd.key /etc/ssl/private/
cp smtpd.crt /etc/ssl/certs/
cp cakey.pem /etc/ssl/private/
cp cacert.pem /etc/ssl/certs/

En este paso configuraremos postfix para que codifique con TLS todo el correo electrónico entrante y saliente (recuerda reemplazar example.com con tu dominio):

postconf -e 'smtpd_tls_key_file = /etc/ssl/private/smtpd.key'
postconf -e 'smtpd_tls_cert_file = /etc/ssl/certs/smtpd.crt'
postconf -e 'smtpd_tls_CAfile = /etc/ssl/certs/cacert.pem'
postconf -e 'tls_random_source = dev:/dev/urandom'

Configurando los límites de los buzones (QUOTAS)

Necesitamos crear un SCRIPT que verifique estos límites y que informe en el momento en que se esté acercando al mismo

cd /usr/local/sbin/
vim quota_notify

En ese archivo ponemos lo siquiente (recordar que hay que cambiar SERVIDOR.DOMINIO.TAL y DOMINIO.TAL donde sea necesario):

#!/usr/bin/perl -w
# Author <jps@tntmax.com>

use strict;

my $POSTFIX_CF = "/etc/postfix/main.cf";
my $MAILPROG = "/usr/sbin/sendmail -t";
my $WARNPERCENT = 80;
my @POSTMASTERS = ('postmaster@DOMINIO.TAL');
my $CONAME = 'My Company';
my $COADDR = 'postmaster@DOMINIO.TAL';
my $SUADDR = 'postmaster@DOMINIO.TAL';
my $MAIL_REPORT = 1;
my $MAIL_WARNING = 1;

#get virtual mailbox base from postfix config
open(PCF, "< $POSTFIX_CF") or die $!;
my $mboxBase;
while (<PCF>) {
   next unless /virtual_mailbox_base\s*=\s*(.*)\s*/;
   $mboxBase = $1;
}
close(PCF);

#assume one level of subdirectories for domain names
my @domains;
opendir(DIR, $mboxBase) or die $!;
while (defined(my $name = readdir(DIR))) {
   next if $name =~ /^\.\.?$/;        #skip '.' and '..'
   next unless (-d "$mboxBase/$name");
   push(@domains, $name);
}
closedir(DIR);
#iterate through domains for username/maildirsize files
my @users;
chdir($mboxBase);
foreach my $domain (@domains) {
        opendir(DIR, $domain) or die $!;
        while (defined(my $name = readdir(DIR))) {
           next if $name =~ /^\.\.?$/;        #skip '.' and '..'
           next unless (-d "$domain/$name");
      push(@users, {"$name\@$domain" => "$mboxBase/$domain/$name"});
        }
}
closedir(DIR);

#get user quotas and percent used
my (%lusers, $report);
foreach my $href (@users) {
   foreach my $user (keys %$href) {
      my $quotafile = "$href->{$user}/maildirsize";
      next unless (-f $quotafile);
      open(QF, "< $quotafile") or die $!;
      my ($firstln, $quota, $used);
      while (<QF>) {
         my $line = $_;
              if (! $firstln) {
                 $firstln = 1;
                 die "Error: corrupt quotafile $quotafile"
                    unless ($line =~ /^(\d+)S/);
                 $quota = $1;
            last if (! $quota);
            next;
         }
         die "Error: corrupt quotafile $quotafile"
            unless ($line =~ /\s*(-?\d+)/);
         $used += $1;
      }
      close(QF);
      next if (! $used);
      my $percent = int($used / $quota * 100);
      $lusers{$user} = $percent unless not $percent;
   }
}

#send a report to the postmasters
if ($MAIL_REPORT) {
   open(MAIL, "| $MAILPROG");
   select(MAIL);
   map {print "To: $_\n"} @POSTMASTERS;
   print "From: $COADDR\n";
   print "Subject: Daily Quota Report.\n";
   print "DAILY QUOTA REPORT:\n\n";
   print "----------------------------------------------\n";
   print "| % USAGE |            ACCOUNT NAME          |\n";
   print "----------------------------------------------\n";
   foreach my $luser ( sort { $lusers{$b} <=> $lusers{$a} } keys %lusers ) {
      printf("|   %3d   | %32s |\n", $lusers{$luser}, $luser);
      print "---------------------------------------------\n";
   }
        print "\n--\n";
        print "$CONAME\n";
        close(MAIL);
}

#email a warning to people over quota
if ($MAIL_WARNING) {
        foreach my $luser (keys (%lusers)) {
           next unless $lusers{$luser} >= $WARNPERCENT;       # skip those under quota
           open(MAIL, "| $MAILPROG");
           select(MAIL);
           print "To: $luser\n";
      map {print "BCC: $_\n"} @POSTMASTERS;
           print "From: $SUADDR\n";
           print "Subject: WARNING: Your mailbox is $lusers{$luser}% full.\n";
           print "Reply-to: $SUADDR\n";
           print "Your mailbox: $luser is $lusers{$luser}% full.\n\n";
           print "Once your e-mail box has exceeded your monthly storage quota\n";
      print "your monthly billing will be automatically adjusted.\n";
      print "Please consider deleting e-mail and emptying your trash folder to clear some space.\n\n";
           print "Contact <$SUADDR> for further assistance.\n\n";
           print "Thank You.\n\n";
           print "--\n";
           print "$CONAME\n";
           close(MAIL);
        }
}

convertimos el archivo en ejecutable

chmod 755 quota_notify

y agregamos el proceso de verificación en CRONTAB

crontab -e

dentro colocamos esta tarea programada:

0 0 * * * /usr/local/sbin/quota_notify &> /dev/null

Así una vez al día (12:00 am) se verificarán los buzones y se enviará un reporte al administrador y si es necesaria una notificación al usuario

Probando el canal cifrado

telnet localhost 25

Esto abrirá una conexión al MTA. Para ver que todo esté en orden se escribe:

ehlo localhost

Y saldrán varias líneas, entre ellas deben estar las siguientes:

250-STARTTLS
250-AUTH LOGIN PLAIN

para salir:

quit

Administrando los buzones, dominios y filtros

Todos los usuarios de correo, los dominios y los filtros se administran a través de la base de datos MySQL. Se puede usar el PHPMYADMIN o la cónsola de mysql. En este caso usaremos la cónsola para agregar los primeros registros (hay que colocar los valores reales, lo siguiente es un ejemplo):

mysql -u root -p
USE mail;
INSERT INTO `domains` (`domain`) VALUES ('dominio.tal');
INSERT INTO `users` (`email`, `password`, `quota`, `local`) VALUES ('usuario@dominio.tal', ENCRYPT('clave_del_usuario'), 10485760, 0);
INSERT INTO `forwardings` (`source`, `destination`) VALUES ('alias@dominio.tal', 'usuario@dominio.tal');
INSERT INTO `filters` (`source`, `action`, `type`) VALUES ('@spamfastidioso.net', 'REJECT envíen spam a su abuelita', 'sender');
INSERT INTO `filters` (`source`, `action`, `type`) VALUES ('@fulanitos.tal', 'OK', 'client');

Es importante notar que la clave de usuario@dominio.tal que hemos creado (clave_del_usuario) se almacena cifrada en la base de datos mediante la función ENCRYPT del MySQL. Todas las contraseñas deberán ser guardadas con este método o no podrá ser posible la autenticación. Si se usa PHPMYADMIN es importante que al almacenar este dato se use esta opción.

Notar también los filtros que se han agregado. El primero rechaza todo correo que venga del dominio “spamfastidioso.net” y el segundo permite cualquier correo del dominio “fulanitos.tal”. Este segundo filtro es útil en los casos donde las políticas de UCE (anti-spam) del POSTFIX generen falsos positivos y esté bloqueando algún servidir de correos mal configurado (típico ejemplo: dominios sin PTR), pero del cual sí queremos recibir envíos.

Finalmente, para que un buzón esté disponible es necesario, después de crearlo en la base de datos enviarle un primer correo, de manera de así generar el directorio donde se almacenarán los archivos de sus correos.

Sergio Ghezzi me escribió un correo para que agregara una forma fácil de hacerlo:

aptitude install mailutils/

Enviamos mail de bienvenida al usuario fulano@dominio.tal

mailx fulano@dominio.tal
Subject: Correo de Prueba

Presionamos ENTER. Luego escribimos el cuerpo del correo y para terminar presionamos CONTROL-D

Hola. Este es un correo inicial para activar tu buzón

(CONTROL-D)

Instalando ROUNDCUBE con plugin para cambio de contraseñas

Primero, nos descargamos las fuentes de ROUNDCUBE de su página principal para el momento de escribir esta documentación, la versión estable es la 0.5.4:

cd /var/www/
wget http://downloads.sourceforge.net/project/roundcubemail/roundcubemail/0.5.4/roundcubemail-0.5.4.tar.gz
tar xzf roundcubemail-0.5.4.tar.gz
mv roundcubemail-0.5.4 correo
chown www-data correo/config correo/logs correo/temp

Luego vamos con nuestro navegador a la dirección web de nuestro ROUNDCUBE para hacer la instalación:

http://dominio.tal/correo

y seguimos los pasos de instalación. Posteriormente quizás sea bueno retocar el archivo de configuración creado (main.inc.php) para ajustarlo a nuestras necesidades. Está suficientemente explicada cada una de las variables que están allí. Por ejemplo es cómodo colocar como fijo el servidor al cual se conectará el cliente de correos ROUNDCUBE:

$rcmail_config['default_host'] = 'localhost';

Procedemos a configurar el plugin para que los usuarios puedan cambiar sus contraseñas. Para ello configuramos el plugin “password”:

cd /var/www/correo/plugins/password
cp config.inc.php.dist config.inc.php
vim config.inc.php

y en ese archivo vamos a modificar los valores de las líneas siguientes:

config.inc.php

$rcmail_config['password_driver'] = 'sql';
$rcmail_config['password_db_dsn'] = 'mysql://mail_admin:XXXXXXXXXXXXX@localhost/mail';
$rcmail_config['password_query'] = 'UPDATE users SET password=ENCRYPT(%p) WHERE email=%u LIMIT 1';

La primera variable le dice al plugin que usará el driver para SQL (en nuestro caso MySQL)

La segunda variable da al plugin acceso a la base de datos. La sintaxis es usuario:clave@localhost/nombre_de_la_bd

La tercera y última variable es el QUERY que hace el cambio de la contraseña en la BD

Lo último que hace falta para que funcione el plugin es declararlo en el archivo de configuración main.inc.php del ROUNDCUBE:

main.inc.php

$rcmail_config['plugins'] = array('password');

Quedará en la sección “SETTINGS” del roundcube.

Reglas contra el SPAM (UCE)

Mucho del SPAM proviene desde sistemas operativos con virus que actuan como “zombies” enviando correo masivamente a internet. La mayoría de las conexiones “caseras” (con pocas excepciones) no tienen direcciones IP que puedan ser usadas como un servicio para SMTP, por lo cual bloquear el SPAM proveniente de esos sistemas zombies es bastante sencillo y efectivo. Para ello se pusieron las siguientes directivas en las distintas directivas donde deben ir en /etc/postfix/main.cf:

reject_invalid_hostname
reject_unknown_recipient_domain
reject_unauth_pipelining
reject_unauth_destination
reject_invalid_helo_hostname
reject_non_fqdn_helo_hostname
reject_unknown_helo_hostname
reject_non_fqdn_sender

Para detalles de que hace cada uno ver la documentación oficial de POSTFIX (leer)

Luego colocamos unos servidores de listas negras, que buscan los dominios reportados como fuente de SPAM y verifican cada petición recibida:

reject_rbl_client blackholes.mail-abuse.org, 
reject_rbl_client cbl.abuseat.org, 
reject_rbl_client dul.dnsbl.sorbs.net

Con eso un buen porcentaje de la cantidad de SPAM diario es reducido. Se han experimentado reducciones de casi todo el SPAM en algunos entornos.

Si después de esto se piensa poner SPAMASSASSIN será porque aún existe una cantidad de SPAM importante. El SPAM es siempre inevitable, lo que se hace con él es mantenerlo a raya lo mejor posible. SPAMASSASSIN consumirá recursos en función de la cantidad de correos enviados. En entornos de mucho tráfico hay que preveer recursos para no generar cuellos de botella.

CLAMAV es opcional en entornos donde se desee hacer detección de virus en el servidor de correos. Esto es opcional y a veces, innecesario. La razón es que todos los servidores de correos principales (gmail, hotmail, etc) poseen sistemas de detección de estos programas dañinos. En los entornos donde todos los clientes son GNU/Linux no es necesaria la instalación de esta herramienta.

Una opción interesante para añadir a esta configuración sería la implementación de POSTSCREEN (leer). Con eso pueden combatirse las máquinas Zombie mucho más efectivamente, en caso de que en entorno donde esté el servidor sea ésta la mayor fuente de SPAM.

Posibles Errores

Si encuentras un error parecido a esto…

Filesystem notification initialization error -- contact your mail administrator (check for configuration errors with the FAM/Gamin library)

Indica que la libreria fam o gamin no está trabajando correctamente en el sistema. Estas librerías permiten a courier monitorizar los cambios en las carpetas del sistema. El problema se solucionará si instalas o reinstalas uno de ellos, podría ser gamin.

aptitude install gamin 

Si encuentras errores del tipo…

postfix/smtp: certificate verification failed for gmail-smtp-in.l.google.com[74.125.53.27]:25: untrusted issuer /C=US/O=Equifax/OU=Equifax Secure Certificate Authority

Es porque Google cambió su proveedor de certificados de Thawte a Equifax y el sistema de correo no es capaz de reconocer la autoridad certificadora Equifax como válida. La solución será añadir una copia del certificado Equifax al almacén de certificados de postfix.

Creamos una copia antes que nada:

cd /etc/postfix/tls/
cp root.crt root.crt.bak

Creamos copias locales de los certificados de Equifax y Thawte

Usando nuestro editor de texto preferido creamos una archivo llamado Equifax_Secure_CA.pem y pegamos lo siguiente:te the following into the file:

-----BEGIN CERTIFICATE-----
MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJVUzEQMA4GA1UE
ChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoT
B0VxdWlmYXgxLTArBgNVBAsTJEVxdWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCB
nzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPR
fM6fBeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+AcJkVV5MW
8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kCAwEAAaOCAQkwggEFMHAG
A1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UE
CxMkRXF1aWZheCBTZWN1cmUgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoG
A1UdEAQTMBGBDzIwMTgwODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvS
spXXR9gjIBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQFMAMB
Af8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUAA4GBAFjOKer89961
zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y7qj/WsjTVbJmcVfewCHrPSqnI0kB
BIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee95
70+sB3c4
-----END CERTIFICATE-----

Ahora creamos un archivo llamado Thawte_Premium_Server_CA.pem y copiamos lo siguiente en él:

-----BEGIN CERTIFICATE-----
MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkExFTATBgNVBAgT
DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3dGUgQ29uc3Vs
dGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UE
AxMYVGhhd3RlIFByZW1pdW0gU2VydmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZl
ckB0aGF3dGUuY29tMB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYT
AlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsGA1UEChMU
VGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRpb24gU2VydmljZXMgRGl2
aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNlcnZlciBDQTEoMCYGCSqGSIb3DQEJARYZ
cHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2
aovXwlue2oFBYo847kkEVdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIh
Udib0GfQug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMRuHM/
qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQQFAAOBgQAm
SCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUIhfzJATj/Tb7yFkJD57taRvvBxhEf
8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JMpAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7t
UCemDaYj+bvLpgcUQg==
-----END CERTIFICATE-----

Añadimos los certificados Equifax y Thawte al certificado root local:

cat /etc/postfix/tls/Equifax_Secure_CA.pem >> /etc/postfix/tls/root.crt
echo >> /etc/postfix/tls/root.pem
cat /etc/postfix/tls/Thawte_Premium_Server_CA.pem >> /etc/postfix/tls/root.crt

El segundo comando añade un salto de linea entre los dos certificados. Finalmente reinicia postfix:

service postfix restart

Ya no deberías ver el mismo error en tu syslog


Cualquier sugerencia, corrección o mejora es bienvenida: octavio@gnu.org.ve

octaviotron/postfix.txt · Última modificación: 2013/12/10 14:43 (editor externo)