URL: https://linuxfr.org/news/heberger-son-courriel Title: Héberger son courriel Authors: claudex Davy Defaud, Benoît Sibaud, ZeroHeure, NeoX, palm123, Anonyme, Benoît, Petit_Scarabee, bastien, titinux et Nicolas Casanova Date: 2013年10月02日T12:44:04+02:00 License: CC By-SA Tags: howto, tutoriel, postfix, spf, dkim, dspam et dovecot Score: 87 Au vu d’un [précédent sondage](//linuxfr.org/sondages/quel-contenu-aimeriez-vous-voir-plus-souvent-sur-linuxfr-org), les lecteurs ont largement envie de plus de _howto_/documentation. Voici donc un tutoriel pour mettre en place une solution pour héberger ses courriels. Jusque‐là, c’est assez classique, mais on va aller un peu plus loin en ajoutant une solution pour lutter contre le pourriel (_spam_), qui apprend en fonction de ce que l’utilisateur configure. Cette solution vise une installation pour quelques utilisateurs maximum (on ne parle pas de LDAP, par exemple). Qui plus est, ils doivent être de confiance, car ils ont accès à certaines commandes qui peuvent poser des problèmes. Ils n’ont pas non plus de quota maximum. L’installation et la configuration ont été testées sur Debian Wheezy, mais devraient fonctionner pour toute distribution. ---- ---- Les paquets à installer sont : postfix, opendkim, dspam, dovecot-imapd, dovecot-lmtpd, dovecot-antispam et dovecot-sieve. #DNS Premièrement, il faut configurer les enregistrements DNS du serveur. Le protocole SMTP a son propre type d’enregistrement DNS, le type `MX`. L’enregistrement donne le nom du serveur et une priorité (il est donc possible d’avoir de la haute disponibilité simplement). Voici un exemple : ``` example.com. 10800 IN MX 0 serveur1.example.com. ↑ ↑ ↑ ↑ (1) (2) (3) (4) ``` - (1) est le domaine où l’on veut envoyer un courriel ; - (2) est le délai, en secondes, pendant lequel l’information peut rester en cache ; - (3) est la priorité, s’il n’y a qu’un seul serveur, ça n’a pas d’importance, s’il y en a plusieurs, cela permet de définir l’ordre dans lequel il faut les contacter ; - (4) est le nom de la machine qu’il faut contacter. Pour éviter de se faire prendre pour un _spammeur_, il est aussi intéressant de configurer un enregistrement [SPF](http://www.openspf.org/). Cela permet de définir quels serveurs sont autorisés à envoyer du courriel pour le domaine spécifié. Le plus simple est d’autoriser uniquement le serveur à envoyer des courriels : ``` example.com. 10800 IN SPF v=spf1 mx -all ``` Avec l’enregistrement précédent, on spécifie que seuls les serveurs enregistrés dans un MX pour _example.com_ peuvent envoyer des courriels provenant de _example.com_. Il faudra donc toujours passer par le serveur pour envoyer des courriels. NdM : autre exemple avec un champ TXT, plus couramment utilisé (cf. le [résumé de S. Bortzmeyer sur la RFC 6686](http://www.bortzmeyer.org/6686.html)) : ``` linuxfr.org. 878 IN TXT "v=spf1 a mx ~all" ``` #Postfix Postfix est un MTA (*Mail Transfer Agent*), il se charge de transférer les courriels qu’il reçoit au bon destinataire qui peut être : soit le serveur en question, si le courriel lui est destiné, soit un autre serveur, si le courriel est destiné à une autre machine (parce que l’utilisateur local l’a envoyé, par exemple). Après l’installation des dépôts de la distribution, il faut adapter le fichier de configuration de Postfix (`/etc/postfix/main.cf`) pour définir le nom d’hôte et les noms de domaines qui sont considérés comme locaux, en modifiant les lignes suivantes : ```sh #On définit le nom d'hôte myhostname = serveur.example.com #On définit l'origine des courriels (ce qu'il faut ajouter après le @ pour les courriels sortants). Attention à remplir le fichier en conséquence myorigin = /etc/mailname #On définit les destinations pour lesquelles on accepte les courriels mydestination = serveur1.example.com, example.com ``` Il peut être intéressant aussi d’augmenter la taille maximum des messages (2 Mio, par défaut) : ```sh #Taille de message de 10 Mio maximum message_size_limit = 10485760 ``` Ensuite, il faut empêcher le serveur d’être un _open mail relay_, c’est‐à‐dire d’envoyer du courriel provenant de n’importe quelle source. Ceci afin d’éviter de relayer du pourriel. Il faut ajouter ou modifier les lignes suivantes (qui sont déjà la configuration par défaut d’un Postfix) : ```sh #les adresses autorisées à envoyer des courriels. Ici seulement l'hôte local mynetworks = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128 #ensuite, on active l'authentification des utilisateurs smtpd_sasl_auth_enable = yes #on utilise dovecot pour authentifier les utilisateurs smtpd_sasl_type = dovecot smtpd_sasl_path = private/auth #on note l'identifiant de l'utilisateur dans les messages smtpd_sasl_authenticated_header = yes #on définit les restrictions, c'est-à-dire les règles de refus ou d'acceptation d'un message, à l'étape RCPT TO, ici en autorisant tous les messages soumis depuis $mynetworks ou depuis un utilisateur précédemment identifié par SASL, en rejetant tous les autres messages à destination de noms de domaines non gérés ou d'utilisateurs inexistants dans les noms de domaines gérés, et en acceptant implicitement tout le reste. smtpd_recipient_restrictions=permit_mynetworks,permit_sasl_authenticated,reject_unauth_destination ``` Contrairement à ce que l’on voit parfois, le port 25 n’est pas dédié à soumettre les courriels à envoyer au serveur, il n’est utile que pour que les *MTA* se parlent entre eux. C’est le port 587 qui est utilisé pour que le client puisse envoyer ses courriels. Pour que Postfix écoute dessus, il faut décommenter (ou ajouter) la ligne suivante dans le fichier `/etc/postfix/master.cf` : ``` submission inet n - - - - smtpd -o syslog_name=postfix/submission -o smtpd_tls_security_level=encrypt -o smtpd_sasl_auth_enable=yes -o smtpd_client_restrictions=permit_sasl_authenticated,reject -o milter_macro_daemon_name=ORIGINATING ``` ##DKIM [[DKIM]] est un service qui permet de signer tous les messages sortants par le serveur. Il n’identifie pas l’auteur du message mais bien le serveur. Cela permet d’être sûr que les messages envoyés par le serveur sont bien légitimes, et permet de refuser les messages qui ne le sont pas et, ainsi, de réduire le pourriel (sauf si votre serveur est un _spammeur_, mais c’est un autre problème). Les clefs cryptographiques (`default.txt`, pour la clef publique, et `default.private`, pour la clef privée) sont générées avec la commande : ``` opendkim-genkey -d example.com ``` Il faut faire attention à se placer dans un dossier uniquement lisible par le démon `dkim`, pour éviter que la clef privée soit lisible par tous. Par exemple, se mettre dans le dossier `/etc/dkim/example.com` et faire un `chown root:opendkim /etc/dkim/example.com/default.private && chmod 400 /etc/dkim/example.com/default.private` une fois que la clef est créée (le changement de groupe n’est pas très utile, mais je trouve que c’est plus cohérent). La clef publique doit ensuite être publiée dans le DNS : ```dns default._domainkey 10800 IN TXT "v=DKIM1; g=*; k=rsa; p=Le_contenu_du_fichier_default.txt" ``` On spécifie aussi la politique de signature (les courriels sont censés être signés) : ``` _adsp._domainkey.example.com 10800 IN TXT "dkim=all" ``` Et, là, les courriels non signés doivent être jetés : ``` _adsp._domainkey.example.com 10800 IN TXT "dkim=discardable" ``` Il faut ensuite modifier le fichier `/etc/opendkim.conf` pour lui inclure les trois lignes suivantes : ``` Domain example.com KeyFile /etc/dkim/example.com/default.private Selector default ``` Il faut aussi ajouter la ligne suivante dans le fichier `/etc/default/opendkim`. Elle permet d’indiquer au démon d’écouter sur une [_socket_ Unix](http://fr.wikipedia.org/wiki/Berkeley_sockets). Comme le démon `smtp` de Postfix tourne dans un `chroot` (c’est la cinquième colonne de la ligne _smtp_ dans le fichier `/etc/postfix/master.cf`), il faut adapter le chemin au `chroot` pour que le démon y ait accès : ```sh SOCKET="local:/var/spool/postfix/var/run/opendkim/opendkim.sock" # chroot Postfix ``` Il faut ensuite créer le dossier et donner les droits à Postfix d’y lire et à OpenDKIM d’y écrire : ```sh mdkir -p /var/spool/postfix/var/run/opendkim chown root:opendkim /var/spool/postfix/var/run/opendkim chmod 775 /var/spool/postfix/var/run/opendkim/ ``` On peut ensuite redémarrer le service OpenDKIM. Il faut maintenant indiquer à Postfix de faire signer les messages qu’il envoie. Pour cela on ajoute les lignes suivantes dans `/etc/postfix/main.cf` : ```sh ## DKIM smtpd_milters = unix:/var/run/opendkim/opendkim.sock non_smtpd_milters = unix:/var/run/opendkim/opendkim.sock ``` Ensuite, on ajoute Postfix au groupe `opendkim` pour qu’il puisse lire les données de la _socket_ : ```sh usermod -aG opendkim postfix ``` On peut enfin indiquer à Postfix qu’il peut transférer les courriels à destination de la machine qu’il reçoit via le protocole LMTP (*Local Mail Transport Protocol*) sur le port 2424, pour que Dspam puisse les analyser : ```sh mailbox_transport = lmtp:inet:127.0.0.1:2424 ``` Voilà, la configuration de Postfix est terminée. On peut redémarrer le service (si vous voulez éviter les surprises, il est quand même recommandé de redémarrer entre les différentes étapes pour voir si vous n’avez pas fait d’erreurs). Vient la configuration de Dspam, pour lui dire d’écouter sur le port 2424. #Dspam Premièrement, dans le fichier `/etc/default/dspam`, il faut modifier les lignes suivantes : ```sh START=yes OPTIONS="--enable-daemon" ``` Ensuite, dans le fichier `/etc/dspam/dspam.conf`, on ajoute : ```sh #Listen a inet socket for incomming mail via lmtp ServerHost 127.0.0.1 ServerPort 2424 ServerMode auto ServerPass.client "password" ``` On configure aussi les informations pour que le client Dspam puisse se configurer (afin de pouvoir envoyer les informations d’apprentissage au serveur) : ```sh #Client configuration Trust mail ClientHost 127.0.0.1 ClientPort 2424 ClientIdent "password@client" ``` Ensuite, on ajoute les utilisateurs de confiance. Avec la configuration donnée, Dovecot tourne sous l’utilisateur qui reçoit les courriels, il faut donc ajouter les utilisateurs qui recevront des courriels (ici, joe) : ``` Trust dspam-user Trust xavier ``` On configure l’hôte et le port sur lesquels tourne le MDA : ```sh #Send scanned mail via lmtp DeliveryProto LMTP DeliveryHost 127.0.0.1 DeliveryPort 24 DeliveryIdent localhost ``` On peut redémarrer dspam. #Dovecot Dovecot est un MDA (*Mail Delivery Agent*) ; c’est‐à‐dire qu’il est en charge de récupérer les courriels et de les envoyer aux clients finaux. La première chose à faire est d’activer l’authentification des utilisateurs pour que Postfix puisse l’utiliser comme on l’a spécifié. On modifie le fichier `/etc/dovecot/conf.d/10-master.conf` comme suit : ```sh service auth { # auth_socket_path points to this userdb socket by default. It's typically # used by dovecot-lda, doveadm, possibly imap process, etc. Users that have # full permissions to this socket are able to get a list of all usernames and # get the results of everyone's userdb lookups. # # The default 0666 mode allows anyone to connect to the socket, but the # userdb lookups will succeed only if the userdb returns an "uid" field that # matches the caller process's UID. Also if caller's uid or gid matches the # socket's uid or gid the lookup succeeds. Anything else causes a failure. # # To give the caller full permissions to lookup all users, set the mode to # something else than 0666 and Dovecot lets the kernel enforce the # permissions (e.g. 0777 allows everyone full permissions). unix_listener auth-userdb { #mode = 0666 #user = #group = } # Postfix smtp-auth unix_listener /var/spool/postfix/private/auth { mode = 0666 } } ``` Après, comme Dovecot reçoit les courriels de Dspam avec une adresse de destination complète et qu’on utilise les utilisateurs du système, il est important de spécifier de n’utiliser que la partie avant le « @ », en modifiant le fichier `/etc/dovecot/conf.d/10-auth.conf` : ```sh auth_username_format = %Ln ``` On spécifie ensuite qu’on va utiliser le greffon antipourriel dans le fichier `/etc/dovecot/conf.d/10-imap.conf` : ```sh protocol imap { mail_plugins = $mail_plugins antispam } ``` Pour pouvoir recevoir les courriels via LMTP, il faut l’activer dans `/etc/dovecot/conf.d/10-master.conf` : ```sh service lmtp { #unix_listener lmtp { #mode = 0666 #} inet_listener lmtp { address = 127.0.0.1 port = 24 } ``` On va maintenant activer les filtres Sieve qui permettent d’appliquer des règles aux messages entrants directement sur le serveur. Premièrement, on l’active dans `/etc/dovecot/conf.d/20-lmtp.conf` : ```sh protocol lmtp { # Space separated list of plugins to load (default is global mail_plugins). mail_plugins = $mail_plugins sieve } ``` Ensuite, on configure le protocole managesieve (qui permet de gérer les filtres Sieve à partir du client de courriel) via le fichier `/etc/dovecot/conf.d/20-managesieve.conf` : ```sh service managesieve-login { inet_listener sieve { port = 4190 } #inet_listener sieve_deprecated { # port = 2000 #} # Number of connections to handle before starting a new process. Typically # the only useful values are 0 (unlimited) or 1. 1 is more secure, but 0 # is faster. service_count = 1 # Number of processes to always keep waiting for more connections. process_min_avail = 0 } ``` Après, on configure le répertoire des filtres Sieves dans `/etc/dovecot/90-sieve.conf` : ```sh plugin { # The path to the user's main active script. If ManageSieve is used, this the # location of the symbolic link controlled by ManageSieve. sieve = ~/.dovecot.sieve # Directory for :personal include scripts for the include extension. This # is also where the ManageSieve service stores the user's scripts. sieve_dir = ~/sieve } ``` On va maintenant parler du greffon antipourriel (_antispam_) de Dovecot, qui permet de gérer l’apprentissage du pourriel en fonction du déplacement du message dans les dossiers. Si vous déplacez le message de votre boîte de réception vers votre dossier `Spam`, il va apprendre à l’antipourriel que c’est un pourriel. Si vous faites l’inverse, il va apprendre à l’antipourriel qu’il a fait une erreur. Ce greffon fonctionne nativement avec Dspam, mais peut fonctionner avec n’importe quel client en appelant un exécutable et en envoyant le message via l’entrée standard. La configuration se fait via `/etc/dovecot/conf.d/90-plugin.conf` : ```sh plugin { antispam_backend = dspam antispam_signature = X-DSPAM-Signature antispam_signature_missing = error #Noms des dossiers antispam_trash = trash;Trash;Deleted Items; Deleted Messages antispam_spam = SPAM;Spam #Configuration du backend dspam antispam_dspam_binary = /usr/bin/dspam #Paramètre à donner à dspam quand le courriel est un spam antispam_dspam_args = --user;%Lu@example.com;--source=error;--class=spam #Paramètre quand le courriel est un ham antispam_dspam_notspam = --user;%Lu@example.com;--source=error;--class=innocent } ``` On remarquera qu’il faut spécifier le domaine d'origine des courriels, sinon il n’est pas passé de Dovecot à Dspam et cela pose des problèmes à ce dernier pour reconnaître les courriels à classer. On peut redémarrer Dovecot. Il faut enfin créer un filtre Sieve pour déplacer les _spams_ dans le dossier approprié, on écrit donc un script dans le dossier `sieve` de l'utilisateur, `/home/joe/sieve/Spam.sieve`, par exemple : ```sh if header :contains "X-DSPAM-Result" "Spam" { fileinto "Spam"; } ``` Et on l’active en créant un lien : ```sh ln -s /home/joe/sieve/Spam.sieve /home/joe/.dovecot.sieve ``` Ces deux dernières étapes peuvent être faites en utilisant un client de courriel qui gère le protocole Managesieve.

AltStyle によって変換されたページ (->オリジナル) /