oMailgw 1.0, un outil libre pour superviser des passerelles SMTP sortantes mutualisées

oMailgw est un logiciel libre que je développe pour répondre à un besoin très concret : gérer, superviser et partager une ou plusieurs passerelles e-mail sortantes basées sur Postfix.

En pratique, c’est l’outil que j’utilise derrière mon offre de passerelle e-mail / relai SMTP : https://retzo.net/services/hebergement/passerelle-e-mail-relai-smtp/

L’idée est de proposer une brique libre et auto-hébergeable pour celles et ceux qui veulent :

  • garder la main sur leur trafic sortant ;
  • mutualiser une ou plusieurs passerelles ;
  • donner de l’autonomie aux utilisateurs sur la lecture de leurs erreurs ;
  • et mieux suivre la réputation / délivrabilité sans devoir tout relire à la main dans les logs. (c’est chouette grep mais quand il faut suivre les rebonds sur plusieurs serveurs ça fait beaucoup de grep… et trop de grep tue le grep)

Le besoin de départ

Quand on exploite une passerelle sortante Postfix, on a vite les mêmes problèmes :

  • certains messages sont refusés ;
  • d’autres sont différés ;
  • des destinataires n’existent plus ;
  • certaines plateformes acceptent puis classent mal ;
  • on peut se retrouver blacklisté à force d’insister vers de mauvaises cibles ;
  • et, côté utilisateurs, la compréhension de ce qui se passe est souvent très limitée.

Sur un petit service mutualisé, ça pose un problème classique : l’administrateur a les logs, mais l’utilisateur ne sait pas forcément pourquoi son trafic passe mal. À l’inverse, laisser tout le monde fouiller dans les logs du serveur n’est évidemment pas une solution.

oMailgw a été pensé pour faire le lien entre ces deux mondes :
donner une vision d’exploitation aux administrateurs, tout en ouvrant une partie de cette visibilité aux utilisateurs, avec des permissions adaptées.

Un projet pensé aussi dans un esprit d’entraide CHATONS

Le projet a aussi été imaginé avec une logique d’entraide entre petites structures, notamment dans un contexte proche de celui des CHATONS.

L’idée de fond est simple : plusieurs petites structures peuvent avoir intérêt à mutualiser du savoir-faire, du monitoring, voire une partie de leur infrastructure de sortie e-mail, tout en gardant chacune leur autonomie.

Dans ce type de scénario, oMailgw permet par exemple :

  • de superviser plusieurs passerelles sortantes ;
  • de suivre les erreurs par serveur, par domaine, par utilisateur ou par authentification SMTP ;
  • de donner à chaque structure ou client une vue limitée à ce qui la concerne ;
  • et, en cas de souci de réputation sur une IP, de mieux comprendre ce qui se passe avant de décider d’un basculement ou d’un rééquilibrage du trafic.

À quoi ressemble l’architecture

Le projet est découpé en trois briques principales :

  • oMailgw API : le cœur applicatif, développé en PHP avec Laravel, avec stockage des données côté base SQL ;
  • oMailgw UI : une interface web en HTML/JS, qui consomme l’API ;
  • oMailgw CLI : un client installé sur une ou plusieurs passerelles utilisant Postfix, chargé de lire les logs et de remonter les informations à l’API via HTTP.

À qui ça s’adresse ?

Je vois plusieurs cas d’usage assez nets.

1. Le petit hébergeur / admin sys qui opère une ou plusieurs passerelles

Cas typique : on a un ou plusieurs Postfix sortants, on veut suivre les erreurs, la file d’attente, les comptes SMTP auth, les messages refusés, les domaines problématiques, et éviter de naviguer uniquement dans les logs système.

2. Le prestataire qui fournit un service de relai SMTP à ses clients

C’est le cas que j’ai chez Retzo : proposer un service de relai SMTP simple à intégrer, avec interface/API de suivi, et laisser les clients consulter leurs propres envois, erreurs et rapports.

3. Un collectif ou une fédération de petites structures

Dans un esprit proche des CHATONS, plusieurs structures peuvent vouloir partager des outils, de la supervision, voire des passerelles de sortie, tout en cloisonnant les accès.

Fonctionnalités principales

Aujourd’hui, oMailgw permet notamment :

  • la consultation des logs de trafic e-mail sortant ;
  • la recherche et le filtrage dans les logs ;
  • la consultation du détail d’un message ;
  • la visualisation des e-mails encore en file d’attente ;
  • des permissions fines selon plusieurs critères, par exemple :
    • expéditeur complet ;
    • domaine expéditeur ;
    • authentification SMTP ;
    • serveur source ;
  • la gestion des authentifications SMTP ;
  • la gestion de transport_map (permet de rediriger une partie du trafic vers l’une ou l’autre des passerelles selon sa réputation) ;
  • la gestion de blacklists manuelles ;
  • des mécanismes d’auto-blacklist (FBL, User Unknown revenu au moins 3 fois…) ;
  • des rapports périodiques par e-mail ;
  • des statistiques sur le trafic et les erreurs ;
  • l’export CSV des logs ;
  • une interface différenciée selon les rôles (root, admin, user, mailgw).

L’un des points auxquels je tenais était l’autonomie utilisateur :

un utilisateur qui envoie réellement via la passerelle peut se créer un compte et consulter uniquement ce qui le concerne, au lieu de dépendre d’une lecture manuelle côté admin.

Ce que la version 1.0 apporte

La 0.9 posait déjà bien les bases, mais la 1.0 marque un cap plus net côté exploitation.

Qualification des bounces

Le gros travail a porté sur la manière de qualifier les erreurs.

Au lieu d’avoir seulement des messages SMTP bruts parfois difficiles à exploiter, la 1.0 introduit une qualification plus homogène :

  • success
  • soft
  • hard
  • unknown

et ajoute des raisons normalisées exploitables côté API, statistiques, dashboard et rapports.

L’objectif est simple : mieux distinguer, par exemple :

  • une erreur temporaire ;
  • une boîte inexistante ;
  • un rejet pour suspicion de spam ;
  • un refus lié à la réputation ;
  • ou un cas plus ambigu qui demande une analyse.

Intégration des FBL

Autre point important : la prise en charge des Feedback Loops (FBL), donc des plaintes remontées quand un destinataire marque un message comme abusif / indésirable.

Dans oMailgw 1.0, ces plaintes peuvent être récupérées via IMAP, intégrées à l’outil, puis relayées par notification aux administrateurs autorisés.

Pour moi, c’est un vrai progrès : on ne regarde plus seulement les messages non délivrés, on commence aussi à voir plus clairement les messages mal reçus.

Rapports plus lisibles

Les rapports périodiques ont été revus :

  • rendu HTML plus propre ;
  • seuils visuels pour repérer plus vite les zones problématiques ;
  • ajout de rapports autour des blacklists et du spool ;
  • personnalisation par utilisateur.

Chaque utilisateur peut désormais mieux définir ce qu’il considère comme une erreur dans ses rapports, avec notamment la possibilité d’inclure ou non les soft bounces dans les statistiques.

Interface plus orientée exploitation

La 1.0 apporte aussi :

  • une administration des utilisateurs réellement finalisée côté root-panel ;
  • un dashboard plus modulaire ;
  • des raisons de bounce visibles dans davantage de vues ;
  • l’export CSV ;
  • une meilleure cohérence entre front et back sur les libellés et le calcul des taux d’erreur.

Démo, code source, documentation

Démo :

Forge / code source :

Plus d’image :

Service utilisant oMailgw :

Annonce de la version 1.0 :

Quelques remarques sur l’état du projet

Le projet m’est d’abord utile à moi, dans un contexte réel d’exploitation.

C’est sans doute aussi ce qui lui donne sa forme actuelle : il ne cherche pas à couvrir tout le champ de l’e-mail, mais à répondre à des besoins concrets de supervision de passerelles sortantes.

La 1.0 ne veut pas dire “projet terminé”, mais plutôt : le socle est là, les usages réels aussi, et l’outil commence à devenir suffisamment cohérent pour être présenté plus largement.

OpenDKIM & Postfix sur debian squeeze

Edit : suite au commentaire de Gaël & mon problème de double signature, sa solution est la bonne, je modifie l’article en conséquence.

Après mettre passé de Amavis/SpamAssasin à Dspam j’ai voulu ré-implémenter DKIM (que j’avais implémenté avec Amavis) cette fois-ci avec OpenDKIM :

Installation :

$ aptitude install opendkim
$ mkdir -p /etc/dkim

Modification du fichier de config postfix (/etc/postfix/master.cf)

smtp      inet  n       -       -       -       -       smtpd
<   -o content_filter=dspam:
>   -o content_filter=dspam: -o smtpd_milters=inet:127.0.0.1:8891

Modification de la configuration d’OpenDKIM (/etc/opendkim.conf) :

Socket          inet:8891@localhost
LogWhy yes
MilterDebug     1

# Log to syslog
Syslog                  yes
# Required to use local socket with MTAs that access the socket as a non-
# privileged user (e.g. Postfix)
UMask                   002

KeyTable           /etc/dkim/KeyTable
SigningTable       /etc/dkim/SigningTable
ExternalIgnoreList /etc/dkim/TrustedHosts
InternalHosts      /etc/dkim/TrustedHosts

Il faut maintenant générer les clefs & ce script va nous y aider :

#!/bin/bash

# Script sous licence BEERWARE

SELECTOR="mail"
REPERTOIRE="/etc/dkim"
DOMAINE=$1
USERDKIM="opendkim"
GROUPDKIM="opendkim"

if ! [ -d "${REPERTOIRE}" ] ; then
    echo "Le répertoire ${REPERTOIRE} n'existe pas."
    exit 1
fi

if [ -z ${DOMAINE} ] ; then
    echo "Vous devez avoir renseigner le domaine en argument du script."
    exit 2
fi

if [ -d "${REPERTOIRE}/keys/${DOMAINE}" ] ; then
    echo "Le répertoire ${REPERTOIRE}/keys/${DOMAINE} existe déjà... vous devez déjà avoir dû lancé le script."
    exit 3
else 
    mkdir -p ${REPERTOIRE}/keys/${DOMAINE}
fi

opendkim-genkey -D ${REPERTOIRE}/keys/${DOMAINE} -r -d ${DOMAINE} -s ${SELECTOR}
chown ${USERDKIM}:${GROUPDKIM} ${REPERTOIRE}/keys/${DOMAINE}/${SELECTOR}.private
echo "${SELECTOR}._domainkey.${DOMAINE} ${DOMAINE}:${SELECTOR}:${REPERTOIRE}/keys/${DOMAINE}/${SELECTOR}.private" >> ${REPERTOIRE}/KeyTable
echo "${DOMAINE} ${SELECTOR}._domainkey.${DOMAINE}" >> ${REPERTOIRE}/SigningTable
echo "${DOMAINE}" >> ${REPERTOIRE}/TrustedHosts

if [ -f ${REPERTOIRE}/keys/${DOMAINE}/${SELECTOR}.txt ]; then 
    cat ${REPERTOIRE}/keys/${DOMAINE}/${SELECTOR}.txt
else 
    echo "Une erreur s'est produite !"
fi

Exemple d’utilisation du script :

$ ./addDkimKey.sh mercereau.info
mail._domainkey IN TXT "v=DKIM1; g=*; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDEOxRe2sVbsmDYbnB1pRWdx5U6FgZiwUKRl0gPFmsgPNA035P7gBLmhXrmALeJLZv0n7ARkStoIvl/ZNAbUep/YUgMynW5q2fsh4Pa/q82ocPKRKGLBYTxFDa+tyhG0oi5pzI6d37Ji9M40c5DgD/2QqTfyY5ywLqKG47+HuivJQIDAQAB" ; ----- DKIM mail for mercereau.info

Le script vous sort l’enregistrement DNS a ajouter pour terminer la configuration

On redémarre les services :

$ service opendkim restart
$ service postfix restart

Et pour finir on test ici ou .

Ce tuto à été très fortement inspiré par le tuto de isalo.org

[ispconfig] Remplacer Amavis/Spamassassin par Dspam

dspam-logo-textAjouter des services décentralisés « à la maison » c’est le bien mais à force d’empiler des briques… ça déborde. Et là j’étais à un stade ou la SWAP était un chouilla trop utilisée.

J’avais déjà désactivé ClamAv (anti-virus) pour économiser de la mémoire vive mais ça ne suffisait pas. Mon autre plus gros poste de dépense en RAM était Amavis/Spamassasin. Je me suis donc mis à chercher une alternative ; La plus légère et efficace semble être DSPAM.

Attention : Le fait de remplacer Amavis/Spamassasin va, de fait vous amputer de fonctionnalité administrable par le panel ISPconfig « Stratégie anti-spam », « liste blanche » car Ispconfig ne support pas (encore !?) DSPAM

Préparation

Étant donné que le serveur est déjà en prod j’ai modifié mon script de firewall (iptables) en spécifiant seulement mon adresse IP pour l’accès au SMTP (pour les tests) ça aura pour effet de faire patienter vos emails en file d’attente sur le serveur émetteur quoi que vous fassiez comme bêtise…

< iptables -A INPUT -p tcp --dport smtp -j ACCEPT
> iptables -A INPUT -p tcp --dport smtp -s VOTRE.IP.DE.MAISON -j ACCEPT

5 jours, c’est par défaut le temps d’attente maximal de la plupart des MTA. Vous pouvez donc théoriquement bricoler pendant 5 jours sans perdre d’email dans cet état…

Installation

Je suis sous Debian squeeze, les paquets Dsapm existe pour squeeze mais dans le backport (non activé pour ma part)

Installation des dépendances :

$ aptitude install libgd-gd2-perl libgd-graph-perl libgd-graph3d-perl libgd-text-perl dbconfig-common postfix-pcre

Ensuite on récupère les paquets sur le site de debian et ont les installent

$ dpkg -i libdspam7_3.10.1+dfsg-3~bpo60+1_amd64.deb
$ dpkg -i libdspam7-drv-mysql_3.10.1+dfsg-3~bpo60+1_amd64.deb
$ dpkg -i dspam_3.10.1+dfsg-3~bpo60+1_amd64.deb
$ dpkg -i dspam-webfrontend_3.10.1+dfsg-3~bpo60+1_all.deb

Note : dbconfig-common va vous demander ce qu’il faut pour créer la base de données.. »suivez le guide. »

Configuration

Postfix

Nous allons, dans postfix désactiver la partie Amavis et activer la partie Dspam /etc/postfix/main.cf :

58c58
< smtpd_client_restrictions = check_client_access mysql:/etc/postfix/mysql-virtual_client.cf
---
> smtpd_client_restrictions = check_client_access mysql:/etc/postfix/mysql-virtual_client.cf, check_client_access pcre:/etc/postfix/dspam_filter_access
71,72d70
< content_filter = amavis:[127.0.0.1]:10024
< receive_override_options = no_address_mappings
74a73,76
>
> dspam_destination_recipient_limit = 1

Même chose dans le fichier /etc/postfix/master.cf :

smtp      inet  n       -       -       -       -       smtpd
11a12
>    -o content_filter=dspam:
116,129c117,118
< 127.0.0.1:10025 inet n - - - - smtpd
<         -o content_filter=
<         -o local_recipient_maps=
<         -o relay_recipient_maps=
<         -o smtpd_restriction_classes=
<         -o smtpd_client_restrictions=
<         -o smtpd_helo_restrictions=
<         -o smtpd_sender_restrictions=
<         -o smtpd_recipient_restrictions=permit_mynetworks,reject
<         -o mynetworks=127.0.0.0/8
<         -o strict_rfc821_envelopes=yes
<         -o receive_override_options=no_unknown_recipient_checks,no_header_body_checks
<         -o smtpd_bind_address=127.0.0.1
< 
---
> dspam   unix    -       n       n       -       10      pipe
>         flags=Rhqu user=dspam argv=/usr/bin/dspam --deliver=innocent --user $user -i -f $sender -- $recipient

Dspam

Dans mon cas j’ai choisi de tout le temps délivrer les SPAM et de tagger le sujet. L’apprentissage se fera via l’interface web (dont nous verrons la configuration plus tard)

Activer le démarrage de Dspam /etc/default/dspam

< start=NO
---
> start=YES

La configuration de Dspam à largement été inspiré du howto d’UNIX garden :

29c29
< StorageDriver /usr/lib/dspam/libhash_drv.so
---
> StorageDriver /usr/lib/dspam/libmysql_drv.so
48c48
< TrustedDeliveryAgent "/usr/bin/procmail"
---
> TrustedDeliveryAgent "/usr/sbin/sendmail"
144c144
< Trust root
---
> #Trust root
146,149c146,149
< Trust www-data
< Trust mail
< Trust daemon
< Trust amavis
---
> #Trust www-data
> #Trust mail
> #Trust daemon
> #Trust amavis
151a152
> Trust postfix
297c298
< Preference "signatureLocation=message"	# { message | headers } -> default:message
---
> Preference "signatureLocation=headers"	# { message | headers } -> default:message
371a373,380
> MySQLServer     	127.0.0.1
> #MySQLPort
> MySQLUser               dspam
> MySQLPass               MOTDEPASSEDEMALADE
> MySQLDb                 dspam
> MySQLCompress           true
> MySQLUIDInSignature    on
> 
471c480
< LocalMX 127.0.0.1
---
> #LocalMX 127.0.0.1

Pour finir sur les tags j’ai dû faire la chose suivante :

$ mkdir /var/spool/dspam/txt/
$ echo ‘Scanned and tagged as SPAM by DSPAM’ > /var/spool/dspam/txt/msgtag.spam

Premier test

Redémarrage des services pour appliquer tous ces changements :

$ service amavis stop
$ service postfix restart
$ service dspam start

Pour tester vous pouvez en envoyer un message avec la commande telnet. Voici un petit script pratique pour automatiser le test :

#!/bin/bash
from="nimportequi@domain.fr"
to="david@domain.fr"
smtp="smtp.domain.fr"
(
    sleep 1
    echo "ehlo x"
    sleep 1
    echo "mail from:${from}"
    sleep 1
    echo "rcpt to:${to}"
    sleep 1
    echo "data"
    sleep 1
    echo "subject:Test message"
    sleep 1
    echo "from:${from}"
    sleep 1
    echo "to:${to}"
    sleep 1
    echo " "
    echo "Coucou."
    sleep 1
    echo "."
    sleep 1
    echo "QUIT"
) | telnet ${smtp} 25

Dans les entêtes du message vous devriez avoir du X-DSPAM comme ceci :

X-DSPAM-Result: Innocent
X-DSPAM-Processed: Thu Jul 1 00:03:19 2050
X-DSPAM-Confidence: 0.9751
X-DSPAM-Probability: 0.0000
X-DSPAM-Signature: 1,51e7a147199049585619662

Si tout fonctionne on dégage amavis (dit « le gros amavis ») du démarrage :

update-rc.d dspam defaults
update-rc.d amavis remove

Sinon fouiller vos logs (/var/log/mail.log /var/log/syslog…)

Interface web

L’interface web est en CGI et nous allons utiliser apache & suexec (qui est déjà embarqué avec ISPconfig) pour le faire tourner

Voici la configuration du virtualhost (sites-available/dspam)

<IfModule mod_suexec.c>
    <VirtualHost *:80>
        DocumentRoot /var/www/dspam

        # Problème css, image : 
        Alias /usr/share/dspam /usr/share/dspam

        ServerName dspam.domain.fr
        ServerAdmin dspam@domain.fr

        SuexecUserGroup dspam dspam

        <Directory /var/www/dspam>
            Options ExecCGI
            Options -Indexes
            Addhandler cgi-script .cgi
            DirectoryIndex dspam.cgi
        </Directory>

        <Directory />
            Options FollowSymLinks
            AllowOverride None
            Order allow,deny
            allow from all
            AuthType Basic
            AuthName "Restricted DSPAM user"
            Auth_MYSQLhost localhost
            Auth_MYSQLusername ispconfig
            Auth_MYSQLpassword MOTDEPASSESUPERCHAUD
            Auth_MYSQLdatabase dbispconfig
            Auth_MYSQLpwd_table mail_user
            Auth_MYSQLuid_field login
            Auth_MYSQLpwd_field password
        </Directory>
    </VirtualHost>
</IfModule>

On active le virtualhost :

$ a2ensite dspam
$ service apache2 graceful

On ajoute le compte admin de l’interface :

$ echo "david" > /etc/dspam/admins

Vous devriez maintenant pouvoir vous rendre sur l’interface :

  • http://dspam.domain.fr/ (interface utilisateur)
  • http://dspam.domain.fr/admin.cgi (interface d’administration)

Conclusion

L’objectif premier était d’économiser de la mémoire vive, c’est chose faite ! la preuve en image :

memory-day

Je suis aussi très satisfait de l’apprentissage de DSPAM. Au début ça peut faire peur parce qu’il laisse vraiment tout passer, mais l’apprentissage est rapide et significatif :

Les premiers jours d'utilisation de DSPAM
Les premiers jours d’utilisation de DSPAM

Ressources

Les sites ressources que j’ai utilisées :

ISPconfig – service email : DKIM & Amavis

By Nemo (Public Domain CC0)

Edit 13/04/2015 : Ajout d’@mynetworks pour que les réseaux connus soient marqués DKMI.

DKIM (DomainKeys Identified Mail)  est une norme d’authentification par clef publique/privé du nom de domaine de l’expéditeur d’un courrier électronique. Une partie de la signature est comprise dans l’entête du message & une autre dans un enregistrement DNS TXT dédié.

Elle constitue une protection efficace contre le spam et l’hameçonnage. Elle permet aussi surtout (et c’est en ça qu’elle nous intéresse le plus) d’éviter de se faire considérer comme SPAM.

Je parle d’ISPconfig dans mon titre car c’est ce qui motorise mon serveur en ce moment, mais je pense que la procédure fonctionne avec Amavis en règle générale.

Mise en place

Il faut déjà préparer le terrain :

srv:~$ mkdir /etc/amavis/pki
srv:~$ ln -s /etc/amavis/pki /var/lib/amavis/pki

Ensuite on génère la clef :

srv:~$ amavisd-new genrsa /var/lib/amavis/pki/dkmi-mercereau.info-key.pem

Puis il faut créer le fichier /etc/amavis/conf.d/99-dkmi avec la configuration suivante :

$enable_dkim_verification = 1;
$enable_dkim_signing = 1;
dkim_key('mercereau.info', 'default', '/var/lib/amavis/pki/dkmi-mercereau.info-key.pem');
@dkim_signature_options_bysender_maps = (
    { '.' => { ttl => 21*24*3600, c => 'relaxed/simple' } } 
);
@mynetworks = qw(0.0.0.0/8 
                127.0.0.0/8     
                123.123.123.123/32  # IP maison 1
                456.456.456.456/32  # IP boulot
);

Ensuite il faut redémarrer le service Amavis :

srv:~$ service amavis restart

Ensuite récupérer la clef DKIM qu’il va falloir insérer dans votre enregistrement DNS avec la commande suivante : :

srv:~$ amavisd-new showkeys
; key#2, domain mercereau.info, /var/lib/amavis/pki/dkmi-mercereau.info-key.pem
default._domainkey.mercereau.info.    3600 TXT (
  "v=DKIM1; p="
  "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDvF925xN7NeMekLrSMSTtZaSx6"
  "9u6njS+mG99DcM1kqj+9RW79KsdKxNXlMull3Mcp6KwKHV7eb8bSvx2TeJ0YUxuA"
  "hZK0dc971R+F6Xmq4fYW02PeuF1fiyl2oL/rxojGT20anxEc9hzFR8jaCFv4CXhh"
  "1efU2BxngTD/onYQVQIDAQAB")

Il faut donc créer un enregistrement DNS comme tel :

default._domainkey 18000 TXT « v=DKIM1; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
[..]
QVQIDAQAB »

Vérification

Après propagation DNS (que vous pouvez vérifier avec l’outil Dig), vous pouvez lancer la commande :

srv:~$ amavisd-new testkeys
TESTING#2: default._domainkey.mercereau.info => pass

Pour être vraiment certain que votre message est signé vous pouvez vous envoyer un email sur une adresse externe et vérifier les entêtes. Sinon vous pouvez envoyer un email à : check-auth [arobase] verifier.port25.com et vous reverser un rapport complet sur « l’état de votre port 25 »

==========================================================
Summary of Results
==========================================================
SPF check: pass
DomainKeys check: neutral
DKIM check: pass
Sender-ID check: pass
SpamAssassin check: ham

[…]
———————————————————-
SpamAssassin check details:
———————————————————-
SpamAssassin v3.3.1 (2010-03-16)

Result: ham (-2.0 points, 5.0 required)

La partie importante pour nous est donc le DKIM check qui doit être à « pass ». D’autre part je ne peux que vous conseiller d’ajouter aussi un enregistrement SPF.

Le rapport m’indique que j’ai un SpamAssassin score de -2 ce qui est très bon car la configuration par défaut de SpamAssassin annonce les messages en SPAM lorsqu’il dépasse un score de +5.

Ressources :

ImapSpamScan.pl – Anti-spam IMAP distant / déporté

imapSpamScan.pl - scriptPour des besoins personnels j’ai codé un petit script en Perl (toujours sous licence beerware) afin de pouvoir scanner un répertoire IMAP avec la puissance de SpamAssassin à distance. ça s’avère très pratique :

  • Quand on ne maîtrise pas le serveur de messagerie ;
  • Qu’il n’y a pas d’anti-spam (ou un anti-spam tout pourrit) ;
  • Que votre serveur est trop « petit » (en terme de ressource) pour accueillir un SpamAssassin ;

Des solutions anti-spam déporté existait ici ou et même mais elle ne me satisferaient pas pleinement.. Du coup j’ai pris mes petits doigts et c’est partie…

Commentaire

Petit commentaire sur le code (visible dans ma bébé forge) :

  1. Je n’ai pas trouvé mieux que la base sqlite pour dire « hey toi je t’ai déjà scanner je passe mon chemin » Ma première idée était de créer un flags IMAP personnalisé (genre « SpamChecked ») d’après ce que j’ai lu ça n’est pas permis dans le protocole IMAP standard… c’est moche…
  2. (Une amélioration à penser) Il faudrait pouvoir stocker le mot de passe en crypté.. le hic est qu’il faut que ça soit réversible pour le servir au serveur IMAP (?) là si quelqu’un à des idées je suis preneur…

Utilisation

Installer les lib perl dépendante :

Sous Ubuntu/Debian :

$ aptitude install libmail-imapclient-perl libmail-spamassassin-perl  libdbi-perl libdbd-sqlite3-perl

Sinon pour les perl compilé ou autres systèmes :

$ cpan -i Mail::SpamAssassin Mail::IMAPClient DBI

Télécharger  :

$ git clone https://forge.zici.fr/source/vrac.git
$ mkdir /opt/imapSpamScan
$ cp vrac/imapSpamScan.pl /opt/imapSpamScan
$ chmod +x imapSpamScan/imapSpamScan.pl

La commande à mettre au lancement de votre poste (dans /etc/xdg/autostart.. ou /etc/rc.local ou .bashrc ou … ou …)

$ /opt/imapSpamScan/imapSpamScan.pl --daemon --imapsrv=serveur.a.scanner.fr --imapuser=brad --imappassword=pitt --db=~/.config/imapSpamScan.db

Installer Postgrey avec Postfix (Greylist) + postgreyreport

Postgrey permettra à votre serveur mail de lutter de manière radicale contre le Spam..

Son fonctionnement est simple, il refuse une première fois n’importe quel mail qui arrive et enregistre l’IP de l’hôte distant, les vrais serveurs mail gardent les messages en queue et tentent de les renvoyer quelques minutes plus tard.

C’est là que Postgrey acceptera le message, seulement s’il est renvoyé : Les spammeurs ne renvoient que très rarement un même mail avec une même IP. Nous utiliseront donc une blacklist pour supprimer ceux qui auraient réussi à passer.

Le greylist se base sur le respect de la RFC 2821, page 4647

Lorsqu’un même serveur envois 5 mails et qu’ils sont valides, il enregistre automatiquement son IP en whitelist.

Installation :

aptitude install postgrey

Editer le fichier /etc/postfix/main.cf :

smtpd_recipient_restrictions = check_policy_service inet:127.0.0.1:60000

Pour avoir des rapports sur l’acivité de postrey taper :

cat /var/log/mail.log | postgreyreport --nosingle_line --check_sender=mx,a --separate_by_subnet=":==================\n

En continuant à utiliser le site, vous acceptez l’utilisation des cookies (au chocolat) Plus d’informations

Les cookies sont utilisés à des fin de statistique de visite du blog sur une plateforme indépendante que j'héberge moi même. Les statistiques sot faites avec un logiciel libre. Aucune information n'est redistribué à google ou autre. Je suis seul autorisé à lire ces informations

Fermer