J’avais dit il y a un certain temps que j’allais écrire un tutoriel expliquant comment gérer ses mails soi-même. Il se trouve que j’ai récemment décidé de changer le serveur qui héberge (entre autres) ce blog, et que ce dernier héberge aussi mes emails. J’ai donc totalement changé d’infrastructure quand a la gestion de mon système de mails.

Ainsi, j’ai décidé de passer de Postfix a OpenSMTPd, changement que je voulais effectuer depuis un certain temps. OpenSMTPd est un projet originaire d’OpenBSD qui a pour but de fournir un serveur SMTP fiable, simple, rapide, et surtout sécurisé (les même buts que ceux qu’a le projet OpenBSD, globalement).

Pour rappel, le système d’emails fonctionne d’une façon très simple : votre MUA (Mail User Agent, ou client email) contacte le MTA (Mail Transport Agent, ou serveur SMTP) de votre fournisseur email, qui contacte le MTA du fournisseur du destinataire, qui lui même contacte le MDA (Mail Delivery Agent) qui délivre le mail au destinataire.

Si vous avez bien suivi, vous pouvez voir que je n’ai pas parlé de récupération ni de lecture des mails. C’est pour une raison simple, qui est que ces taches sont remplies par d’autres services encore (IMAP/POP pour la récupération depuis le serveur, des yeux pour la lecture).

Or ce qui nous intéresse ici, ce n’est pas simplement d’envoyer et de recevoir des emails mais bien aussi de pouvoir les récupérer et les lire, et c’est pour ça que ce tutoriel ne parlera pas que d’OpenSMTPd mais aussi de Dovecot qui fait office de serveur IMAP et amavis/spamassassin pour filtrer les mails entrants et sortants. Le schéma suivant explique la façon dont les mails sont gérés sur le système

            ╭────────────────╮                    ╭──────────╮
            │╭──────────────>│────> to filter ───>│─╮        │
  mail in   ││               │                    │ │ amavis │
───────────>│╯ OpenSMTPd  ╭──│<─── from filter<───│<╯        │
            │             │  │                    ╰──────────╯
  mail out  │             │  │                    ╭──────────╮
<───────────│<────────────┴─>│─────> to MDA ─────>│─────────>│──> to user's
            │                │                    │ dovecot  │     mailbox
            ╰────────────────╯                    ╰──────────╯

Normalement, ceci devrait être a peu près clair. Pour expliquer vite fait, les emails entrants (venant des utilisateurs mais aussi d’autres correspondants) sont transmis a OpenSMTPd, qui envoie tout aamavis, qui vérifie a la fois les spams et les malwares pour les mails venants de l’exterieur, et qui signe avec DKIM pour les mails venants de nos utilisateurs, puis qui rentransmet les mails filtrés/signés a OpenSMTPd, qui a ce moment-ci trie en fonction de la destination : les mails gérés par le domaine vont via dovecot dans les boites mail des destinataires locaux, les mails exterieurs vont directement vers le MTA du serveur distant.

Voyons comment mettre cela en place. Tout d’abord, il faut décider de la façon dont les différents services vont communiquer.

Déjà, amavis étant configuré par défaut pour écouter (en SMTP) sur le port 10024 et répondre sur le port 10025 quand il s’agit de filtrer et écouter sur le port 10026 et répondre sur le port 10027 quand il s’agit de signer, nous allons profiter de cette configuration et donc lui parler en SMTP sur ces ports.

Quand a Dovecot, nous allons lui transmettre les emails en LMTP (Local Mail Transfer Protocol), non pas sur un port mais via un socket (dans ce cas précis, /var/run/dovecot/lmtp).

Ainsi, pour reprendre le schéma présenté plus haut :

            ╭───────────────╮                    ╭───────────╮
            │╭─────────────>│──> SMTP (10026) ──>│─╮         │
  SMTP in   ││              │                    │ │ amavis  │
────────> 25│╯ OpenSMTPd ╭──│<── SMTP (10027) <──│<╯ (sign)  │
            │            │  │                    ╰───────────╯
  SMTP out  │            │  │
25 <────────│<───────────╯  │
            ╰───────────────╯

Pour les mails sortants; et

            ╭───────────────╮                    ╭────────────╮
            │╭─────────────>│──> SMTP (10024) ──>│─╮          │
  SMTP in   ││              │                    │ │ amavis   │
────────> 25│╯ OpenSMTPd ╭──│<── SMTP (10025) <──│<╯(filter)  │
            │            │  │                    ╰────────────╯
            │            │  │                    ╭────────────╮
            │            ╰─>│──> LMTP (socket) ─>│───────────>│──> to user's
            │               │                    │  dovecot   │     mailbox
            ╰───────────────╯                    ╰────────────╯

Pour les mails entrants.

Maintenant que la théorie est claire, mettons en place tout cela. Je me baserai ici sur le fait que vous utilisiez une plateforme Debian ou OpenBSD. Pour d’autres plateformes, la configuration devrait être sensiblement la même

(Vous aurez besoin de certificats SSL pour ce guide, même auto-signés. Si vous ne savez pas comment en créer, vous pouvez aller voir ce post)

Tout d’abord, commençons par installer les programmes nécessaires :

sudo apt-get install opensmtpd dovecot dovecot-pigeonhole amavisd-new dovecot-managesieved
sudo pkg_add dovecot dovecot-pigeonhole amavisd-new

Continuons en configurant OpenSMTPd tel que nous avons vu plus haut :

/etc/smtpd.conf

# This is the smtpd server system-wide configuration file.
# See smtpd.conf(5) for more information.

## Certs
pki exem.pl certificate "/etc/certs/exem.pl.crt"
pki exem.pl key         "/etc/certs/exem.pl.key"

## Ports to listen on, and how to listen on them
listen on eth0 port 25 tls pki exem.pl hostname exem.pl auth-optional
listen on eth0 port 465 tls-require pki exem.pl hostname exem.pl auth mask-source
listen on eth0 port 587 tls-require pki exem.pl hostname exem.pl auth mask-source

## Aliases
table aliases file:/etc/aliases

# coming from amavisd, checked for spam/malware
listen on lo port 10025 tag Filtered
# coming from amavisd, signed with DKIM
listen on lo port 10027 tag Signed

## Receiving
# if the (incoming) mail has been through amavisd, then we can deliver it
accept tagged Filtered for any alias <aliases> deliver to lmtp "/var/run/dovecot/lmtp"
# we directly tranfer incoming mail to amavisd to be checked 
accept from any for domain "exem.pl" relay via "smtp://localhost:10024"
# we have to put these lines in this order to avoid infinite loops

## Sending
# if the (outgoint) mail has been through amavisd, then we can deliver it
accept tagged Signed for any relay
# we tranfer the outgoing mail to amavisd to be signed
accept for any relay via "smtp://localhost:10026"
# same, we have to put these lines in this order or infinite loops...

Expliquons un peu ce fichier de configuration :

• Tout d’abord, le paragraphe nommé “Certs” contient les déclaration d’emplacement des certificats SSL.
• Ensuite, le paragraphe contenant les ports externes sur lesquels nous écoutons : port 25 avec TLS optionel et ports 465 et 587 avec TLS obligatoire
• Les alias sont définis juste après
• Le paragraphe suivant contient les ports locaux sur lesquels nous écoutons : 10025 (port de sortie du filtre de amavis) dont on taggue les mails sortants comme “Filtered” et 10027 (port de sortie des mails signés par amavis) dont on taggue les mails sortants comme “Signed”
• Nous avons ensuite le paragraphe qui traite les mails rentrants. Si le mail traité est taggué comme Filtered, alors il a été vérifié par amavis, et on peut donc le transmettre au destinataire. Sinon, c’est qu’il n’a pas encore été vérifié par amavis, donc on lui transmet pour analyse (sur le port 10024 donc). Il est important de mettre les déclarations dans ce sens, car la première règle qui matche l’état du paquet est appliquée. Ici, la deuxième ligne matchant tous les mails arrivant et la première seulement ceux filtrés, inverser leur sens voudrait dire que les mails seraient toujours renvoyés a amavis
• Enfin, le dernier paragraphe traite les mails sortants. De la même façon que pour le paragraphe précédent, si le mail sortant est déjà taggué comme Signed on le transmet au MTA du destinataire, sinon il n’a pas encore été signé par DKIM par amavis et on le transmet donc a amavis pour qu’il le signe. Le problème de l’ordre des lignes se pose encore, pour la même raison qu’au dessus.

Nous allons maintenant configurer dovecot. Comme nous l’avons vu, dovecot doit écouter en LMTP via la socket /var/run/dovecot/lmtp et transmettre les emails a la boite email de l’utilisateur. Il serait aussi interessant qu’il nous permette de récuperer les mails. Pour cette configuration, on ne mettra en place que du IMAPS. Cependant, si vous voulez mettre en place du POP3[s], différents guides sont trouvables facilement sur internet.

/etc/dovecot/dovecot.conf

## Dovecot configuration file

# basic config
info_log_path = /var/log/dovecot-info.log
log_path = /var/log/dovecot.log
log_timestamp = "%Y-%m-%d %H:%M:%S "
mail_location = maildir:%h/mail

# authentication
passdb {
    driver = pam
}
userdb {
    driver = passwd
}

# the protocols we use
protocols = imap lmtp sieve

# ssl config
ssl_cert = </etc/certs/exem.pl.cert
ssl_key = </etc/certs/exem.pl.key
ssl_cipher_list = HIGH+kEDH:HIGH+kEECDH:HIGH:!PSK:!SRP:!3DES:!aNULL
ssl = yes

## configuring services 
# disables imap login without SSL (yes dovecot is dumb that way)
service imap-login {
    inet_listener imap {
        port=0 
    }
}

service lmtp {
    unix_listener lmtp {
        mode = 0666
    }
}

## configuring protocols
# the dovecot lda, we set it to use sieve
protocol lda {
    mail_plugins = $mail_plugins sieve
}

protocol lmtp {
    postmaster_address =  whoever@exem.pl
    mail_plugins = $mail_plugins sieve
}

plugin {
    sieve = ~/.dovecot.sieve
    sieve_dir = ~/sieve
}

ATTENTION: Sous OpenBSD, remplacez

passdb {
    driver = pam
}

par

passdb {
    driver = bsdauth
}

pour identifier les utilisateurs système

Ici aussi, voyons comment ce fichier est structuré :

• Tout d’abord, les configurations de base : ou iront les logs, comment formater leur datation, et l’endroit ou seront stockés les mails des utilisateurs.
• Nous configurons ensuite la gestion de l’authentification des utilisateurs. Ici nous identifions les utilisateurs avec le fichier /etc/passwd et leurs mots de passe avec PAM (ou BSDAuth)
• Nous configurons ensuite les protocoles que nous servons. Ici, nous voulons de l’IMAPS, du LMTP local et Sieve (qui sert pour trier les messages).
• Nous configurons le SSL
• Le section suivante contient la configuration des services. Nous avons en premier lieu le service IMAP, dont la configuration sert uniquement a désactiver IMAP. En effet, dovecot ne permet d’activer IMAPS qu’en activant IMAP avec. Comme nous ne voulons pas d’IMAP sans SSL, nous le désactivons. La configuration de lmtp sert a attribuer des permissions plus correctes au fifo qu’il utilise
• Nous configurons maintenant les protocoles, pour faire fonctionner Sieve
• enfin, nous configurons le plugin sieve en lui indiquant quel fichier et quel dossier utiliser pour sa configuration.

Enfin, il nous reste a configurer amavis. Comme expliqué, amavis va nous servir a deux choses : signer les emails sortants, et filtrer les emails entrants. Il doit donc écouter sur les port 10026 pour les signatures et 10024 pour le filtrage, et répondre respectivement sur les ports 10027 et 10025 (le tout, en SMTP. Comme toutes les transactions se font sur le loopback, il n’y a aucun risque a utiliser des protocoles non chiffrés. Pour OpenBSD, pensez a copier la configuration par défaut depuis/usr/local/share/examples/amavisd-new/amavisd.conf et ajoutez les modifications nécessaires a la fin du fichier.

/etc/amavis/conf.d/99-local.conf (debian) /etc/amavis.conf (OpenBSD)

use strict;

$enable_dkim_verification = 1;
$enable_dkim_signing = 1;
dkim_key("exem.pl", "main", "/etc/certs/dkim.key" );

@dkim_signature_options_bysender_maps = (
    { '.' =>
        { ttl => 21*24*3600, c => 'relaxed/simple' }
    }
);

$inet_socket_port = [10024, 10026];
$policy_bank{'MYNETS'} = {
        originating => 1,
        os_fingerprint_method => undef,
};

$interface_policy{'10026'} = 'ORIGINATING';

$policy_bank{'ORIGINATING'} = {
        originating => 1,
        allow_disclaimers => 1,
        virus_admin_maps => ["root\@$mydomain"],
        spam_admin_maps => ["root\@$mydomain"],
        warnbadhsender => 1,
        forward_method => 'smtp:localhost:10027',
        smtpd_discard_ehlo_keywords => ['8BITMIME'],
        bypass_banned_checks_maps => [1],
        terminate_dsn_on_notify_success => 0,
};

#------------ Do not modify anything below this line -------------
1;  # ensure a defined return

A nouveau, expliquons ce fichier : - le premier paragraphe définit que nous voulons qu’amavis signe les emails sortants, vérifie la signature DKIM des emails rentrants, et l’endroit ou se trouve la clé privée servant a signer les emails. - le second définit les options DKIM que nous souhaitons utiliser comme défaut. Je vous invite a consulter la RFC 4871 - nous définissons ensuite les ports sur lesquels nous allons écouter, puis les paramètres que nous utiliserons pour les emails venant de nos utilisateurs : ils seront traités comme “originating” et nous ne vérifierons pas l’OS duquel ils viennent. - nous savons que les emails venants du port 10026 sont sortants, nous les traitons donc comme tel - le paragraphe suivant décrit le traitement que nous faisons subir aux emails sortants : tout d’abord, nous réaffirmons qu’ils viennent bien de notre serveur. Nous autorisons les disclaimers (voire encore une fois la RFC 4871. Nous déclarons l’adresse a prévenir en cas de spam/virus venants de notre système, et que nous voulons être prévenus. Nous déclarons ou envoyer les mails une fois signés et filtrés, puis qu’il est nécessaire de convertir les emails au format 7 bits avant de les envoyer au MTA, que nous autorisons tous les types et noms de fichiers, et les notifications de succès d’envoi. Et voila!

Vous avez pu remarquer qu’a aucun moment nous ne configurions ni la signature des emails sortants ni le filtrage des emails entrants. Ces paramètres sont en fait inclus par défaut dans amavis.

Il nous reste cependant quelques opérations a faire, encore. Tout d’abord, il nous faut générer notre clé DKIM. Pour cela, il existe différentes méthodes, j’ai personnellement utilisé opendkim (un tutorial) mais de nombreuses autre méthodes existent. Il nous reste encore a configurer spamassassin :

#rewrite_header Subject *****SPAM*****
# report_safe 1
required_score 2.0
# use_bayes 1
# bayes_auto_learn 1
# bayes_ignore_header X-Bogosity
# bayes_ignore_header X-Spam-Flag
# bayes_ignore_header X-Spam-Status
ifplugin Mail::SpamAssassin::Plugin::Shortcircuit
# shortcircuit USER_IN_WHITELIST       on
# shortcircuit USER_IN_DEF_WHITELIST   on
# shortcircuit USER_IN_ALL_SPAM_TO     on
# shortcircuit SUBJECT_IN_WHITELIST    on
# shortcircuit USER_IN_BLACKLIST       on
# shortcircuit USER_IN_BLACKLIST_TO    on
# shortcircuit SUBJECT_IN_BLACKLIST    on
shortcircuit ALL_TRUSTED             off
# shortcircuit BAYES_99                spam
# shortcircuit BAYES_00                ham

endif # Mail::SpamAssassin::Plugin::Shortcircuit

Comme vous pouvez le voir, les modifications se résument globalement a baisser le required_score pour ma part.

Pour finir, activez les services nécessaires : opensmtpd, dovecot, amavisd, et spamassassin, et tout devrait fonctionner parfaitement

Bon courage pour votre hosting de mail ensuite…

J’ai récemment eu l’occasion de louer un serveur chez Online.net (filiale de Illiad) Voulant depuis pas mal de temps gérer un serveur sous FreeBSD (et tester bhyve) et n’ayant pour différentes raisons pas eu l’occasion de le faire sur mon serveur auto-hebergé ni sur ce serveur ci, j’ai commencé a chercher comment le faire sur ce serveur.

Étant donné que Online ne propose pas directement d’image FreeBSD sur ses serveurs, il m’a fallu chercher un peu plus loin. Il se trouve que ce post sur les forums d’online explique une procédure, mais celle-ci ne fonctionnait pas pour mon serveur en particulier.

J’ai donc cherché un peu sur internet, puis demandé sur irc (#freebsd-fr@freenode), ou l’on m’a dirigé vers mfsbsd, un projet d’installeur alternatif, minimaliste et simplifié pour FreeBSD.

Pour installer FreeBSD sur votre serveur, donc, il vous faudra accéder a une console KVM (dans mon cas personnel, iLO). Cela doit être faisable depuis le panel Online. Une fois cela fait, lancez une console, puis téléchargez l’image mfsbsd. Dans la console iLO, choisissez de booter sur une image CD/DVD, puis choisissez l’image mfsbsd. Ensuite, rebootez le serveur. Choisissez de booter sur l’image CD/DVD (F11 puis 1). Une fois ceci fait, un FreeBSD a l’air tout a fait classique va démarrer. Une fois ceci fait, la partie importante arrive: mfsbsd contient un script d’installation root-on-zfs, nommé logiquement zfsinstall, qui va se charger de tout le travail pour nous.

Utilisez donc ce script ainsi :

# tout d'abord, wipons le MBR :
dd < /dev/zero > /dev/da0 count=1
# maintenant, installons le système
zfsinstall -g da0 -u ftp://ftp.freebsd.org/pub/FreeBSD/releases/amd64/10.0-RELEASE/ -s 2G -p root -c

Avec -g da0 votre disque dur principal, -s 2G la quantité de swap désirée, -p root le nom du zpool, et -c pour activer la compression. D’autres options sont disponibles, je vous invite a faire un zfsinstall -h si mon setup ne vous convient pas.

Une fois ceci fait, faites un chroot dans /mnt (ou doit se trouver le nouveau système) et éditez /etc/rc.conf :

zfs_load="YES"
sshd_load="YES
hostname="whatever"
ifconfig_igb0="DHCP"

Remplacez whatever par votre hostname, et igb0 par le nom de votre interface physique connectée a internet. Quittez le chroot, rebootez, et voila, vous avez maintenant un système FreeBSD tout propre installé sur zfs a découvrir et utiliser!

Voila, c’est la fin de ce tutoriel. (Cela dit, bon courage pour tester bhyve, vu que l’IPv6 chez online est… peu crédible, disons)

Bon sinon sur d’autres sujets, j’ai mis en place des bots twitter : wxcafe_ebooks, petitefanfare, capet_ebooks, zengisse, et kim_ebooks. Ils sont tous basés sur ce code, qui vient de @m1sp (github.com/twitter_ebooks). Donc voila.

A plus

Le DNS (Domain Name System) est le service permettant la résolution des noms de domaines en différentes informations : adresses IPv4, adresses IPv6, certificats DNSSEC ou IPsec, localisation géographique, ou encore texte. En général, le DNS est utilisé pour résoudre des noms de domaines en adresses IP, et ainsi pour simplifier la vie de tous les utilisateurs (je doute que tout le monde retienne de se connecter a http://173.194.45.66, ou a http://199.16.156.70. Voire même a http://5.39.76.46).

Cependant, le DNS est un système qui date de 1984, et les exigences de l’époque en termes d’expérience utilisateur n’étaient pas forcément aussi importantes que de nos jours. La configuration des serveurs DNS peut ainsi être assez contre intuitive. Cela étant dit, comprendre le fonctionnement de DNS et contrôler ses enregistrements est important.

Tout d’abord, une petite explication théorique. Le DNS fonctionne de la même façon que le système de fichiers : en arborescence. Cependant, là ou la racine du FS est /, celle de DNS est ., et là ou il convient d’écrire, par exemple,/usr/ et ou la progression se fait de gauche a droite pour le FS, pour DNS le . n’est pas obligatoire et la progression se fait de droite a gauche. Par exemple, le tld(top level domain, domaine de haut niveau) com, et le domaine google.com appartient a com, on écrit donc google.com sans écrire le point a la fin de façon courante.

Le reverse DNS est une variante du DNS “classique” permettant de résoudre les adresses IP en nom de domaine. Ainsi, 5.39.46.76 a pour domaine wxcafe.net. Cependant, le reverse DNS n’a, par définition, pas de TLD sur lequel se diriger quand on lui adresse une query. Les “adresses” que l’on query en reverse DNS sont donc constituées de l’adresse IP, dans le sens contraire a l’ordre habituel, et du faux domaine .in-addr.arpa Par exemple, pour connaitre le reverse de 5.39.46.76, il faudra faire dig PTR 76.46.39.5.in-addr.arpa. La réponse sera, évidemment, wxcafe.net

Voyons maintenant comment mettre en place son propre serveur DNS. Tout d’abord, quelques informations. DNS fonctionne sur le port 53 en UDP, et la commande utilisée pour faire des tests DNS est dig. Le DNS fonctionne avec des “enregistrements”, records en anglais. Par exemple, un record A indique une adresse IP, un record NS indique un Serveur de nom, etc. dig se base sur ces records : par défaut, il ira chercher le(s) record(s) A correspondant(s) au nom de domaine que vous donnez en argument, mais en précisant un autre type de record, vous pouvez obtenir n’importe quelle information : par exemple, dig NS wxcafe.net devrait vous renvoyer

; <<>> DiG 9.8.4-rpz2+rl005.12-P1 <<>> NS wxcafe.net
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 13846
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;wxcafe.net.            IN  NS

;; ANSWER SECTION:
wxcafe.net.     3600    IN  NS  ns.wxcafe.net.
wxcafe.net.     3600    IN  NS  ns.home.wxcafe.net.

;; Query time: 60 msec
;; SERVER: 10.0.42.1#53(10.0.42.1)
;; WHEN: Tue Dec 10 13:31:18 2013
;; MSG SIZE  rcvd: 67

Comme vous pouvez le voir, les serveurs DNS principaux pour wxcafe.net sont ns.wxcafe.net et ns.home.wxcafe.net, qui sont respectivement des alias pour wxcafe.net et home.wxcafe.net. Ainsi, chacun fait autorité pour lui même, et le problème évident est que le résolveur ne peut résoudre la query si il est renvoyé encore et encore vers le même serveur. Il convient donc de définir dans le même fichier de configuration l’adresse de ces deux serveurs. Ainsi, le résolveur, au bout de son deuxième loop, se rendra compte qu’il est en train de faire une boucle infinie et demandera l’adresse au serveur auquel il est connecté. La première indication de direction se fait grâce au serveur du TLD.

La configuration de bind est assez simple dans le principe, le plus complexe étant en fait d’écrire les fichiers de zone. La configuration de bind sous debian se fait dans le dossier /etc/bind/. Il existe 4 fichiers de configuration principaux : named.conf, named.conf.default-zones, named.conf.local et named.conf.options. named.conf contient les options par défaut de bind, named.conf.default-zones les déclarations des zones par défaut (auxquelles il vaut mieux ne pas toucher), named.conf.local contient les déclarations de vos zones, et named.conf.options contient les options que vous rajoutez pour changer le comportement de bind.

Pour commencer, il convient de préciser que nous allons parler ici du cas dans lequel se trouve wxcafe.net: deux domaines dont nous voulons faire l’autorité, deux serveurs DNS, et un service de résolution récursive limitée a quelques IPs (notamment mon accès chez moi).

Examinons tout d’abord les fichiers de configuration de named.named.conf.local contient les définitions des zones forward et reverse. Sur wxcafe.net, les zones wxcafe.net et 76.46.39.5.in-addr.arpa sont gérées en master, et les zones home.wxcafe.net et 103.177.67.80.in-addr.arpa sont gérées en slave. Nous n’examinerons ici que les déclarations de zones sur ce serveur, et pas sur home., car elles sont sensiblement les mêmes. La différence principale étant que l’un héberge en slave les masters de l’autre. Le fichier named.conf.local sur wxcafe.net contient donc

zone "wxcafe.net" {
    type master;
    file "/etc/bind/master/wxcafe.net";
    allow-transfer {
        80.67.177.103;
    };
};

zone "home.wxcafe.net" {
    type slave;
    file "/etc/bind/slave/home.wxcafe.net";
    masters {
        80.67.177.103;
    };
};

zone "46.76.39.5.in-addr.arpa" {
    type master;
    file "/etc/bind/master/46.76.39.5.in-addr.arpa";
    allow-transfer {
        80.67.177.103;
    };
};

zone "103.177.67.80.in-addr.arpa" {
    type slave;
    file "/etc/bind/slave/103.177.67.80.in-addr.arpa";
    masters {
        80.67.177.103;
    };
};

Cela devrait être relativement clair. Globalement, les zones master ont un fichier dans /etc/bind/master/, et les slaves un fichier dans /etc/bind/slave/, les masters autorisent le transfert vers home.wxcafe.net tandis que les slaves déclarent home.wxcafe.net comme master, et le reste est assez parlant.

Voyons maintenant le fichier de zone concernant wxcafe.net, soit /etc/bind/master/wxcafe.net :

$TTL 3600    ; 1 hour
@               IN SOA ns.wxcafe.net. wxcafe.wxcafe.net. (
                        2014011001  ; serial
                        3h          ; refresh  
                        1h          ; retry
                        168h        ; expire
                        300         ; negative response ttl
                        )

; Name servers
                IN  NS      ns.wxcafe.net.
                IN  NS      ns.home.wxcafe.net.

; Mail exchangers
                IN  MX  10  wxcafe.net.
                IN  SPF "v=spf1 ip4:5.39.76.46 a -all"

; Main A/AAAA records
                IN  A       5.39.76.46
ns              IN  A       5.39.76.46

; Aliases
data            IN  CNAME   wxcafe.net.
;        [...]
www             IN  CNAME   wxcafe.net.


; home.wxcafe.net. definition
$ORIGIN home.wxcafe.net.
@               IN  NS      ns.home.wxcafe.net.
                IN  NS      ns.wxcafe.net.
ns              IN  A       80.67.177.103
                IN  A       80.67.177.103

Alors. Expliquons ligne par ligne.
Tout d’abord, le TTL (time to live) est un paramètre définissant le temps pendant lequel les serveurs récursif (qui font un cache des données) doivent cacher ce fichier de zone.
Le @ est un raccourci pour exprimer le nom de domaine courant. Ici, donc, wxcafe.net.
Maintenant, nous arrivons a un record important : SOA (Start of Authority). Ce record prend de nombreux arguments, dans l’ordre :
- Le nameserver autoritaire pour le nom de domaine en question,
- L’adresse email du responsable de cette zone, avec le premier point remplacé par un @,

puis entre parenthèses :
- Le numéro de série (“version” du fichier de zone, ici au format YYYYMMDDNN)
- La période de refresh, période entre chaque mise a jour du nameserver authoritaire secondaire,
- La période de retry, le temps entre chaque essai de mise a jour si le nameserveur authoritaire primaire est indisponible,
- La période d’expire, le temps qu’attendra le serveur autoritaire secondaire avant de supprimer les informations de son cache si le primaire reste indisponible, et enfin
- La période de TTL négatif, le temps qu’attendra le serveur secondaire avant de ne plus offrir les informations de cette zone si le serveur primaire est injoignable.

Bon, tout ceci est peut-être un peu confus, mais ce n’est pas le record le plus important a lire (pour les humains en tout cas). Continuons :

NS (nameserver) permet de désigner les différents nameservers faisant autorité pour ce domaine.

MX permet d’indiquer ou il convient d’envoyer les emails pour ce domaine. SPF est un record d’authentification pour les emails. Les records A désignent l’association entre un nom de domaine et une adresse IPv4. Les records AAAA font de même pour les IPv6, mais malheureusement ce site n’est pas encore en IPv6.

Les CNAME (canonical name) sont en quelque sorte des alias, ils permettent de mettre en place des domaines exactement semblables a d’autre (ce qui permet par exemple de filtrer ensuite avec les Virtual Hosts d’Apache, pour le web)

Enfin, la partie qui suit commence avec une déclaration $ORIGIN, ce qui permet de changer la valeur du @ et des noms de domaine non complets (qui ne se terminent pas avec un .). Ainsi, la partie suivant définit les nameservers et l’adresse IP principale de home.wxcafe.net et de ns.home.wxcafe.net. Comme on l’a vu, étant donné que ce nom de domaine est géré par un autre serveur DNS, cela permet de rediriger les requêtes nous parvenant et demandant un domaine se trouvant sous home.wxcafe.net.

Les autres fichiers de zone sont sensiblement similaires, avec les quelques différences n’étant en fin de compte que des différences de valeurs (dues au fait que, eh bah, c’est pas les mêmes domaines…).

Voila donc une courte explication de ce qu’est le DNS. Bien entendu, tout n’est pas expliqué ici, je ne suis passé que sur ce qui est en place au niveau de wxcafe.net, et encore, rapidement. Si vous voulez en savoir plus, vous pouvez aller vous renseigner directement a la source : le RFC 1034 et le RFC 1035. Dans un autre style (bien plus avancé) le blog de Stéphane Bortzmeyer est interessant aussi.

sed est un outil Unix très largement utilisé et très pratique pour manipuler le texte (ce qui se montre relativement indispensable dans un environnement Unix, puisque ce système est assez porté sur le texte). Cependant, il assez peu connu en détail, et la plupart du temps une seule fonction est utilisée : le remplacement de texte.
Or sed a bien plus de possibilités que ça, comme nous allons le voir.

Tout d’abord, rappelons les bases : sed est un programme Unix de base, mais aussi un langage de manipulation de texte dérivé de ed, l’éditeur original.ed est un éditeur de ligne, conçu a l’époque ou les ordinateurs n’étaient pas personnels et étaient utilisés avec des téléscripteurs, c’est a dire des machines dépourvues d’écrans et ne permettant donc pas l’utilisation d’éditeurs dits “visuels”, tels que vim, emacs, et globalement tous les éditeurs ayant un curseur et affichant plusieurs lignes. sed est donc une évolution de ed, le s signifiant stream, sed est un éditeur de flux, prenant donc avantage du concept Unixien de flux de données (voir Flux standards) pour éditer plus d’une ligne a la fois. En pratique, sed est principalement utilisé sur des fichiers.

sed a quelques options pratique, notamment -s qui permet d’empêcher l’affichage systématique des lignes traitées, ou bien -i (pour GNU sed) qui permet de rediriger l’output dans le fichier d’input. Cela dit, l’intérêt unique du programme est son langage de manipulation de texte.

ed, et donc sed, utilise un langage basé sur les séparations (en général des /). Ainsi, la commande de base dans sed est

/[regex]/

qui permet de ne sélectionner que les lignes qui matchent [regex] (et donc de n’exécuter les commandes qui suivent que sur ces lignes.)

La commande sed la plus utilisée est bien entendu le s, qui s’utilise de la façon suivante :

s/[old text]/[new text]/[options]

qui se propose donc de remplacer (substitute) [old text] (qui peut être une regex) par [new text] (qui doit être un texte fixe, avec quelques exceptions), en appliquant [options], la plus connue des options étant g, qui permet d’appliquer la commande affectée a toutes les occurrences du texte matché sur la/les lignes concernée-s.
Les exceptions a la “fixité” de [new text] sont particulièrement intéressantes. En effet, sed utilise un langage de regex plutôt standard, excepté le fait qu’il permet jusqu’à 9 “holding spaces”, qui sont délimités par \( et \), et qui sont représentées dans le texte de remplacement par \1 à \9.

Par exemple, la commande

sed 's/\(hello world\) world/\1/'

sur le texte “hello world world” renverrait comme résultat

hello world

De la même façon, le symbole & dans le texte de remplacement représente le texte original. Ainsi, la commande

sed 's/hello world/& world/'

sur le texte “hello world” renverrait comme résultat

hello world world

Une autre commande utile est p, qui sert a afficher le texte présent dans l’espace courant :

/[regex]/p

sed stocke en effet la ligne sur laquelle il travaille dans un espace mémoire dédié, que j’appelle l’espace courant (pattern space en anglais). La commandep affiche (print) ce qui ce trouve dans cet espace. La /[regex]/ réduit le pattern space de façon a ce qu’il ne contienne que les lignes matchant, et le p affiche donc ce dernier.

Un autre exemple de commande sont c, i et a, qui s’utilisent ainsi :

c \
[text]

De la même façon, pour le i :

i \
[text]

Et de même pour a.

Ces trois commandes s’utilisent de la même façon pour la bonne raison qu’elles sont très proches. i sert a insérer du texte avant le pattern space. a sert a insérer du texte après le pattern space, et enfin c sert a remplacer tout le pattern space. Les trois utilisent [text] comme remplacement ou insert. Attention, les insertions se font sur la ligne précédant ou suivant le pattern space, et non sur la ligne en question.

Enfin, dernière commande ne fonctionnant que ligne par ligne, d : /[regex]/d d (delete) supprime les contenus du pattern space.

sed est un outil puissant, mais complexe. Dans un prochain article, je parlerai des commandes multilignes et des labels.

Le chiffrement en tant que concept informatique est traditionnellement associé au chiffrement de fichiers, c’est a dire au fait de passer d’un fichier en clair a un fichier chiffré dit cyphertext. Cependant, il ne se limite pas a ça, et peut aussi servir a garantir l’intégrité d’un système d’exploitation, ou bien la confidentialité d’un support de stockage, par exemple. Nous allons ici voir comment mettre en place un système de ce type sous GNU/Linux. Cet article n’a pas pour but de vous apprendre a mettre en place un système basé sur une procédure de boot sécurisée, mais plutôt d’expliquer les concepts qui entrent en jeu dans l’utilisation du sous-système du noyau Linux dm_crypt et de présenter un rapide tutoriel concernant la création d’un support chiffré sur lequel garder vos informations confidentielles (par exemple, votre clé GPG)

dm-crypt est un sous-système de device-mapper, qui est lui-même un sous-système du noyau Linux, et s’appuie sur LUKS, un standard de chiffrement de disques. Comme son nom l’indique, device-mapper est un système qui a pour but de mapper des block devices. Pour être plus clair, le kernel considère comme “block device” tout fichier spécial (en gros, les fichiers disques dans/dev/, les systèmes de fichiers type LVM, les RAID logiciels, et, dans le cas qui nous intéresse, les systèmes de fichier chiffrés). Son mode de fonctionnement est simple : a partir d’un “fichier de périphérique” (trad. Wikipédia), il en “crée” un nouveau, virtuel, ayant des propriétés différentes. Par exemple, un disque partitionné via LVM apparaîtra comme un seul disque dans /dev, et device-mapper est requis pour pouvoir en voir les partitions (qui apparaîtront donc dans /dev/mapper)

Ainsi, dans le cas qui nous intéresse ici, device-mapper prend un système de fichier chiffré, crée un périphérique virtuel non chiffré dans /dev/mapper, et déchiffre a la volée tous les accès disques a ce périphérique non chiffré en les traduisant sur le système de fichier chiffré, le tout de manière tout a fait transparente pour les applications utilisant le disque en question. Cela induit bien entendu une baisse de performance relativement significative dans le cas d’un chiffrement du système de fichier root, mais quasiment insignifiante dans le cas de chiffrement de partitions de données.

D’ailleurs, certain-e-s se demandent peut-être comment le système peut démarrer si le système de fichier root est chiffré. Dans ce cas précis, la procédure de boot doit s’appuyer sur une image initrd (l’initrd est un système de fichier minimal qui sert uniquement a initialiser le système. Les kernels de base de la plupart des distributions GNU/Linux en utilisent un dans tous les cas, pour des raisons de compatibilité) et sur une partition de boot qui elle n’est pas chiffrée. Ainsi, le bootloader de niveau 2 (grub, syslinux,…) charge en mémoire le kernel depuis la partition de boot, puis ce dernier décompresse et charge l’initrd en RAM, celui-ci a son tour lance un script permettant de charger les modules nécessaires a la suite du boot (que ce soit pour un boot sans disque root local, ou bien comme ici avec un système chiffré), puis le système de fichier “cible” est remonté sur la racine, et l’initrd est démonté est la RAM qu’il occupait est libérée, puis la procédure de boot normale reprend depuis le système de fichier maintenant monté sur la racine.

La méthode la plus évidente pour contourner le chiffrement du disque est alors de remplacer le fichier compressé initrd dans /boot, qui n’est pas chiffrée, par un autre modifié, copiant par exemple la phrase de passe permettant de déchiffrer la partition cible. Plusieurs méthodes permettent de se prémunir contre ce genre d’attaques : l’une des plus simple est de faire un checksum du fichier initrd utilisé et reconnu comme sûr, et de vérifier lors du vrai boot que l’initrd présente toujours le même checksum. Cela dit, cette méthode a l’inconvénient d’intervenir après les faits, et de nécessiter au moins un accès a un fichier initrd reconnu comme sûr.
Une autre approche consisterait a placer le système de fichier /boot sur un périphérique dédié, protégé en écriture de façon matérielle (par exemple, une carte SD) ou, de façon encore plus efficace, sur un périphérique chiffré et protégé en écriture de façon matérielle. Ainsi, il n’est pas possible pour un attaquant de modifier ce système de fichier, et l’initrd est alors toujours de confiance. Cependant, cela a pour conséquence de rendre la mise a jour de l’initrd et du noyau beaucoup plus difficile qu’elle ne le serait sans.

Pour en revenir aux systèmes de fichiers chiffrés, leur gestion est faite par un programme dédié, cryptsetup. Ce dernier était en charge de cryptoloop, l’ancien sous-système de chiffrement du kernel Linux (déprécié depuis), et est maintenant responsable de l’utilisation userspace de dm-crypt, qui pour sa part est entièrement kernel-space. Cryptsetup permet ainsi le chiffrement, la manipulation (montage/démontage/…) et la gestion de clé des systèmes de fichier LUKS. Cryptsetup est cependant conçu pour être utilisé en tant que root, et les utilisateurs qui veulent monter de systèmes de fichiers chiffrés devront ainsi obligatoirement être capables de le faire en tant que root.

Voyons comment il faudrait procéder pour créer une image disque chiffrée de 1Go :
Tout d’abord, il nous faut créer le fichier qui contiendra l’image. Pour cela, dans une situation réelle ou l’on cherche a chiffrer un disque, il convient d’utiliser /dev/urandom comme source, pour éviter la détection du système de fichier chiffré sur le disque. Ici, par exemple, nous allons faire :

dd bs=1000 count=1000000 if=/dev/urandom of=image.img

Maintenant que notre image est créée, nous pouvons la chiffrer :

sudo cryptsetup luksFormat image.img

cryptsetup va alors nous demander si nous sommes absolument surs de vouloir formater ce disque (nous allons donc valider en tapant YES), puis une passphrase. Il convient ici de choisir une passphrase particulièrement sûre, puisque toute personne ayant accès a la passphrase aura aussi accès au disque et donc a vos secrets.
Une fois cela fait, nous allons mapper cette image :

sudo cryptsetup luksOpen image.img crypto

cryptsetup nous redemande la passphrase, charge pendant quelques secondes, puis nous redonne le prompt. Que s’est-il passé? En cherchant un peu, nous voyons qu’il n’y a pas de nouveau disque dans /dev. C’est tout a fait normal. En effet, cryptsetup (et par lui, device-mapper et dm-crypt) ne monte pas les systèmes de fichiers chiffrés, il les mappe, et ça n’a rien a voir. On remarque qu’est apparu dans /dev/mapper le fichier crypto. Ce fichier est le disque virtuel qui correspond a notre image. Il se comporte comme toute partition, et peut donc être monté, formaté, etc (il ne peut cependant pas être partitionné. Il se comporte en effet comme une partition, et non comme un véritable disque.) Bon, ceci fait, notre disque virtuel n’est pas formaté. Il nous reviens donc de le faire, pour pouvoir l’utiliser.

sudo mkfs.ext4 /dev/mapper/crypto

Maintenant que notre disque est formaté, il peut être monté :

sudo mount /dev/mapper/crypto /mnt

Et voila, nous avons un système de fichier fonctionnel et chiffré! Si vous voulez vérifier, un mount | grep crypto devrait vous donner le résultat suivant :

/dev/mapper/crypto on /mnt type ext4 (rw,relatime,data=ordered)

Vous pouvez maintenant commencer a stocker tous vos secrets sur ce fichier, ils sont (en fonction de votre passphrase) en sécurité.

Pour résumer :

• Pour monter vos partitions :

  sudo cryptsetup luksOpen <fichier chiffré> <nom de disque virtuel>
  sudo mount /dev/mapper/<nom de disque virtuel> <emplacement>
  

• Pour démonter vos partitions :

  sudo umount <emplacement>
  sudo cryptsetup luksClose <nom de disque virtuel>
  

Pour simplifier la vie de tous, j’ai créé deux petits scripts vous permettant de créer et de monter/démonter vos images/disques chiffré-e-s en une seule commande. Ils se trouvent sur github.

Par ailleurs, si vous comptez transferer votre image disque sur un véritable disque (ou clé usb, ou autre), il est préférable de créer une partition de taille appropriée et de faire un dd if=votre_image of=/dev/votre_partition pour ce faire.

Il y a un certain temps, j’avais parlé du concept du self-hosting. Il s’agit de posséder son propre serveur, et donc, par extension, ses données.

Bien entendu, il n’est pas nécessaire pour cela de posséder physiquement son propre serveur (encore que ce soit possible, mais ce n’est pas le sujet abordé ici.)
Nous expliquerons ici les étapes nécessaires pour arriver a avoir un serveur utilisable, du moment ou vous arrivez sur le système fraichement installé, au moment ou vous possédez un serveur avec tous les paquets nécessaires a l’utilisation que l’on veut en faire ici d’installés. Cette partie va consister a paramétrer le système (ici un debian squeeze. Il est bien sur possible de faire la même chose avec a peu près toutes les distributions Linux disponibles, tout comme avec les BSD et tous les autres systèmes UNIX, mais je vais ici me limiter a debian 6.0.x squeeze, parce que c’est une distribution simple a utiliser comme serveur, stable, et facile a configurer (puisqu’une bonne partie de la configuration est déjà faite et incluse dans le paquet), donc adaptée au but de cet article, a savoir rendre l’installation simple et compréhensible).

La première chose a faire est bien entendu d’obtenir le serveur en lui même. Cette partie de la chose ne sera pas traitée dans cet article. Il existe en effet un nombre infini d’obtenir un serveur, que ce soit en le louant chez OVH/1&1/n’importe quel autre hébergeur commercial, en participant a un système d’hébergement collaboratif (je vous laisse chercher), en achetant un serveur et en le faisant fonctionner de chez vous, en utilisant un vieux PC… Bref, les possibilités sont multiples. Dès lors que vous avez accès a un système debian serveur, peu importe sur quel matériel il fonctionne, et a priori peu importe aussi la manière dont vous y accédez, le résultat est le même (et la procédure aussi…). Dans cet article, nous parlerons de la configuration de base, du moment ou vous avez le serveur vierge dans les mains au moment ou vous installez le serveur http.

Dans cet article, lorsque est précisée le type d’IP a utiliser, il convient de mettre ce type précisément. Quand le type n’est pas précisée, libre a vous de choisir ipv4 ou ipv6.

Bref. Commençons au point ou vous avez un accès root a votre serveur, n’ayant soit aucun mot de passe, soit un choisi par l’hébergeur, et ou rien n’est configuré. Connectez vous a celui-ci (ssh root@). Commencez donc par faire un passwd, pour mettre au plus vite un mot de passe solide sur le compte root. Continuons en allant vite mettre en place le nom de domaine. Pour cela, votre registrar doit vous fournir une interface vous permettant d’éditer l’entrée DNS pour votre nom de domaine.

Cette entrée doit donc pour l’instant ressembler a ca :

    <votre nom de domaine>  NS 1 
                            IN MX 1 
                            IN A        <IPv4 de votre serveur>
                            IN AAAA     <IPv6 de votre serveur>

Cela vous permet de rediriger tout le trafic se référant a votre nom de domaine vers votre ip (le fonctionnement exact du DNS est assez compliqué a expliquer, donc on va dire que c’est de la magie pour l’instant, ca sera peut être le sujet d’un autre article), et d’indiquer que les mails @votre-nom-de-domai.ne doivent aussi être redirigés vers votre serveur, ce qui est un bon début. Faisons un petit point sécurité ici : pour accéder a votre serveur, il vous suffit actuellement de taper le mot de passe root.

root est un utilisateur assez répandu, et il est assez simple de bruteforcer le mot de passe. (Relativement assez simple, en fonction du nombre de caractères, ça prend plus ou moins de temps, et si vous avez suffisamment de caractères, ça peut prendre un temps assez conséquent. Cela dit, il vaut mieux être prudent…) Ainsi, nous allons arrêter d’utiliser root et nous allons commencer a utiliser des couples clés publiques/privées pour nous connecter au serveur.
Cela se fait en deux temps : tout d’abord, créer un nouvel utilisateur, grâce auquel nous administrerons le serveur a l’avenir; puis configurer OpenSSH pour que celui ci n’accepte que les connections par clés et plus celles sur root.

Commençons par ajouter un utilisateur. Si vous êtes sous debian, cela se fait avec adduser, qui est interactif (vous ne devriez pas avoir de problème avec, puisqu’il crée tout les dossiers et fichiers nécessaires, et vous pose toutes les questions utiles pour vous aider.) sinon, vous devrez utiliser useradd, qui est (en plus d’être très chiant a distinguer de l’autre, bien plus chiant a utiliser. (adduser est en fait un simple script permettant l’utilisation d’useradd plus facilement.)

Avec adduser, vous pouvez soit utiliser le mode interactif en tapant juste adduser <username>, soit utiliser le mode non-interactif en faisant un adduser --group <username>

Avec useradd, vous devrez utiliser la commande suivante : useradd -m -N -g <username>. Cette commande ajoutera un utilisateur, créera son dossier principal dans /home/, et l’ajoutera au groupe du même nom que lui (ce qui est en général nécessaire pour des questions de vie privée).

Il convient maintenant d’ajouter cet utilisateur aux groupes qu’il sera amené a administrer: usermod <username> -a -G www-data postfix users staff sudo wheel, puis de changer son mot de passe passwd. Enfin, ajoutons le aux utilisateurs autorisés a utiliser sudo: echo "%sudo ALL=(ALL) ALL" >> /etc/sudoers
Enfin, changeons d’utilisateur : su. A ce point, vous avec un utilisateur complètement fonctionnel et utilisable pour toutes les taches d’administration. Si vous devez encore utiliser root, c’est que quelque chose ne va pas.

Vous êtes donc loggés sur le système en tant qu’utilisateur normal. Nous allons maintenant passer a la phase 2 du plan : désactiver le login ssh root et le login ssh par mot de passe.
Tout d’abord, qu’est-ce qu’un login par clé ssh? Il s’agit en fait d’un système assez semblable a celui vous permettant de chiffrer vos mail : vous avec une clé publique et une clé privée sur le client, et la clé publique est aussi sur le serveur. Lorsque vous vous connectez, openssh vérifie que vous possédez la clé privée qui correspond a la clé publique stockée sur le serveur (pour votre utilisateur, bien entendu). Il est également possible d’utiliser plusieurs clés publique pour chaque
utilisateur.

Bref, maintenant que nous avons la théorie, passons a la pratique : tout d’abord, il nous faut générer un couple de clés publique/privée sur le client. Openssh fait ça via la commande ssh-keygen -t rsa (le -t rsa précise a ssh que nous voulons un chiffrement rsa, qui est suffisamment solide pour cette utilisation.) Entrez les informations que ssh-keygen vous demande. Trois fichiers devraient maintenant se trouver dans votre dossier .ssh/ : id_rsa, id_rsa.pub, et known_hosts.
known_hosts liste les serveurs auxquels vous vous êtes connectés déjà une fois (pour éviter les attaques MITM, mais bref). Non, ce qui nous intéresse ici c’est id_rsa et id_rsa.pub . id_rsa contient votre clé privée, sauvegardez la sur une clé USB ou notez la sur un bout de papier, si vous la perdez, vous ne pourrez plus vous connecter au serveur. (planquez la clé usb/le bout de papier…) id_rsa.pub, quand a lui, contient votre clé publique. Copiez la sur le serveur, avec unscp ~/.ssh/id_rsa.pub <username>@<votre nom de domaine>:~/ , ou en la copiant a la main, si ça vous amuse.

Vous avez maintenant un fichier id_rsa.pub dans votre dossier personnel sur le serveur, il faut le mettre a un endroit ou openssh le reconnaitra. Il est donc nécessaire de créer le dossier .ssh (mkdir .ssh), puis de déplacer ce fichier a la bonne place (mv ~/id_rsa.pub ~/.ssh/authorized_keys). Testez si ça fonctionne : ouvez un autre terminal, et
connectez vous a votre serveur (ssh <username>@<votre nom de domaine>), et il ne devrait pas vous demander de mot de passe.Si il vous en demande un, NE PASSEZ PAS A LA SUITE. Quelque chose a foiré, donc vérifiez que vous avez suivi correctement les instruction ci-dessus.

Continuons. Il ne nous reste plus qu’a installer le serveur web, et a le configurer:

sudo apt-get install \
apache2 apache2.2-common apache2-doc apache2-mpm-prefork \
apache2-utils libexpat1 ssl-cert libapache2-mod-php5 \
php5 php5-common php5-gd php5-cgi libapache2-mod-fcgid \
apache2-suexec php-pear php-auth php5-mcrypt mcrypt \
php5-imagick imagemagick libapache2-mod-suphp libruby \
libapache2-mod-ruby

(faisons large, on aura besoin de l’excédent plus tard…), puis activons les
mods apache en faisant a2enmod suexec rewrite ssl actions include dav_fs dav auth_digest, et faisons en sorte que ces activations soient prises en compte par apache via un sudo service apache2 restart

Le serveur fonctionne, maintenant, il est necessaire de lui expliquer comment fonctionner sur notre nom de domaine et ou trouver les fichiers a envoyer.

Pour cela, nous allons faire un simple ln -s /etc/apache2/sites-{available,enabled}/default, car apache est assez sympa pour nous filer un fichier de configuration par défaut. Il nous faut encore l’éditer, en changeant l’adresse mail au début du document par la votre, et en changeant AllowOverride none en AllowOverride All, et enfin redémarrer apache pour qu’il prenne en compte les modifications, par un sudo service apache2 restart

Et maintenant, il vous reste a apprendre le html, parce que ca y est, votre serveur est fonctionnel! Voila voila. Dans la prochaine partie, on verra l’installation du serveur mail (c’est suffisamment complexe pour prendre un article seul…)

Les clients mails ont une particularité en commun : ils sont tous très mauvais. Cela pour nombre de raisons, mais la principale reste que leurs interfaces/raccourcis claviers ne sont pas efficaces pour une utilisation a la UNIX
Cependant, un d’entre eux se démarque par sa moins-mauvais-itude, c’est le relativement bien connu Outlook Express 2003 Mutt!
Mutt est un client mail en ligne de commande, qui, comme le dit sa page d’accueil, “just sucks less”. Dans les faits, mutt est assez chiant a configurer mais particulièrement pratique a utiliser après.

La configuration de mutt se fait dans le fichier .muttrc ou dans /etc/Muttrc, et il est courant d’utiliser offlineimap en conjonction avec celui ci, de façon a accéder aux mails même sans accès internet (mutt dispose d’un système d’accès IMAP/POP et SMTP, mais ne crée pas de cache, ce qui empêche la consultation des emails sans connexion internet.) La configuration d’offlineimap se fait dans~/.offlineimaprc ou dans rien d’autre en fait, c’est une config par user. Offlineimap est un petit logiciel en python qui synchronise un dossier en Maildir avec un serveur IMAP, ce qui tombe bien puisque justement mutt accepte les dossiers au format Maildir. (De plus, cela va tout a fait dans le sens de la libération des données en cela que vous possédez vos mails en local.)
Bref, passons aux choses serieuses : le code. Déjà, installez offlineimap et ce script fait par moi, qui vous permet d’installer mutt avec le patch sidebar, qui crée un listing des dossiers sur la partie gauche.
Ensuite, voyons pour la partie configuration :
Ma configuration d’offlineimap :

## Config file for offlineimap
## Originally located in ~/.offlineimaprc
## This should not be edited without creating a copy before
## Created by Wxcafe (Clément Hertling)
## Published under CC-BY-SA

[general]
# List of accounts to be synced, separated by a comma.
accounts = main

[Account main]
# Identifier for the local repository; e.g. the maildir to be synced via IMAP.
localrepository = main-local
# Identifier for the remote repository; i.e. the actual IMAP, usually non-local.
remoterepository = main-remote
# Status cache. Default is plain, which eventually becomes huge and slow.
status_backend = sqlite              # le type de cache. (plain ou sqlite)

[Repository main-local]
# Currently, offlineimap only supports maildir and IMAP for local repositories.
type = Maildir                        # le type de stockage (Maildir ou IMAP)
# Where should the mail be placed?
localfolders = ~/Emails/                # le dossier dans lequel vous
                                        # voulez que vos emails apparaissent

[Repository main-remote]
# Remote repos can be IMAP or Gmail, the latter being a preconfigured IMAP.
type = IMAP
remotehost = //placeholderhost//        # le serveur de votre messagerie
remoteuser = //placeholderusername//    # votre nom d'utilisateur
remotepass = //placeholderpassword//    # votre mot de passe
cert_fingerprint = //placeholdercert//  # le certificat du serveur (IMAPS only)

Ça devrait être assez simple a lire, j’ai tout bien commenté :3
Puis ma config mutt :

## Mutt MUA configuration file
## This file should not be edited without creating a copy
## File Created and edited by Wxcafe (Clément Hertling)
## Published under CC-BY-SA

# General config for reading (fetched via offlineimap)

set mbox_type = Maildir
# type de boite mail (voir dans offlineimap, mailbox par defaut)

set folder = ~/Email/
# dossier root mailbox/imap

set spoolfile = +INBOX
# dossier d'inbox

set mbox = +'All Mail'
# dossier ou archiver les emails

set copy = yes
# yes pour copier les messages dans les differents dossier, no pour...
# enfin voila quoi.

set header_cache = /.hcache/
# dossier ou sont stockés les headers (pour le cache)

set record = +Sent
# dossier dans lequel sont stockés les messages envoyés

set postponed = +Drafts
# dossier dans lequel sont stockés les brouillons

mailboxes = +INBOX +Drafts +Sent +Trash  +All\ Mail 
# liste des dossiers qui vont apparaitre dans la colonne de gauche

# General config for sending (using Mutt's native support)

set smtp_pass = 'password_placeholder'
# votre mot de passe

set smtp_url = "smtp://username@whatev.org:465/"
# l'url ou envoyer les emails

set send_charset = "utf-8"
# UTF8, NE PAS CHANGER

set signature = ".sign"
# vous pouvez mettre votre signature dans .sign

set sig_on_top = yes
# il est d'usge de mettre no ici. Cependant, je trouve ca plus lisible 
# comme ca.

set ssl_verify_host = no
# mettez yes ici si votre serveur a un certificat configuré correctement

set hostname = "wxcafe.net"
# mettez l'adresse de votre serveur ici

# Misc settings

auto_view text/html
# la façon de voir les emails par défaut.

set date_format = "%y-%m-%d %T"
# format de date d'envoi/de reception.

set index_format = "%2C | %Z [%D] %-30.30F (%-4.4c) %s"
# format de l'index (la présentation de l'interface)
# voir http://www.mutt.org/doc/manual/manual-6.html#index_format

set sort_alias = alias
set reverse_alias = yes 
set alias_file = "$HOME/.mutt/aliases"
# liste des alias noms/email. a créer et remplir vous même.
# format : "alias short_name long_email_adress"
source $alias_file

set beep = no
# ne pas biper. CE SON ME TUE T.T

set tilde = yes
set sleep_time = 0
# ?

set sidebar_visible = yes
set sidebar_width = 15
# parametres de la barre coté gauche

set realname = "Clément Hertling (Wxcafé)"
set from = "wxcafe@wxcafe.net"
set use_from = yes
set certificate_file = "$HOME/.mutt/cacert"
# parametres d'envoi. mettez vos propres infos a la place des miennes...

set edit_headers = yes
# vous permet de vois les headers des mails. j'aime, donc je laisse.

# Macros

# le titre dit tout. index veut dire que la macro est active dans les menus,
# pager qu'elle l'est dans la visionneuse, les deux qu'elle l'est dans les 
# deux
# \C represente la touche Control

bind index,pager \Cp sidebar-prev
# Control+p -> remonter d'un dossier dans la sidebar

bind index,pager \Cn sidebar-next
# Control+n -> descendre d'un dossier dans la sidebar

bind index,pager \Co sidebar-open
# Control+o -> ouvrir le dossier selectionné dans la sidebar

macro index,pager d "=Trash" "Trash"
# d supprime le message en cours

bind pager   previous-line
# permet de monter d'une ligne avec la touche up, au lieu de changer de message.

bind pager   next-line
# permet de descendre d'une ligne avec la touche down, au lieu de changer de 
# message

bind pager j next-line
bind pager k previous-line
# raccourcis vim

# PGP signing commands

set pgp_decode_command="gpg %?p?--passphrase-fd 0? --no-verbose --batch --output - %f"
set pgp_verify_command="gpg --no-verbose --batch --output - --verify %s %f"
set pgp_decrypt_command="gpg --passphrase-fd 0 --no-verbose --batch --output - %f"
set pgp_sign_command="gpg --no-verbose --batch --output - --passphrase-fd 0 --armor --detach-sign --textmode %?a?-u %a? %f"
set pgp_clearsign_command="gpg --no-verbose --batch --output - --passphrase-fd 0 --armor --textmode --clearsign %?a?-u %a? %f"
set pgp_encrypt_only_command="pgpewrap gpg --batch --quiet --no-verbose --output - --encrypt --textmode --armor --always-trust --encrypt-to 0x******** -- -r %r -- %f"
set pgp_encrypt_sign_command="pgpewrap gpg --passphrase-fd 0 --batch --quiet --no-verbose --textmode --output - --encrypt --sign %?a?-u %a? --armor --always-trust --encrypt-to 0x******** -- -r %r -- %f"
set pgp_import_command="gpg --no-verbose --import -v %f"
set pgp_export_command="gpg --no-verbose --export --armor %r"
set pgp_verify_key_command="gpg --no-verbose --batch --fingerprint --check-sigs %r"
set pgp_list_pubring_command="gpg --no-verbose --batch --with-colons --list-keys %r" 
set pgp_list_secring_command="gpg --no-verbose --batch --with-colons --list-secret-keys %r" 
set pgp_autosign=yes
set pgp_sign_as=0x********
# remplacez 0x******** par votre identifiant PGP!!!!!

set pgp_replyencrypt=no
set pgp_timeout=7200
set pgp_good_sign="^gpg: Good signature from"

# si vous ne comptez pas utiliser PGP, commentez toute cette section, depuis
# PGP signing options

# Palette for use with the Linux console.  Black background.

# Schéma de couleur Rouge et Noir. Commentez si vous voulez le 
# défaut noir et blanc.
# d'autres schémas sont trouvables sur google et autre.

color hdrdefault red black
color quoted brightblack black
color signature brightblack black
color attachment red black
color message brightwhite black
color error brightred black
color indicator black red
color status white black
color tree white black
color normal white black
color markers red black
color search white black
color tilde brightmagenta black
color index red black ~F
color index red black "~N|~O"

Voila, pour plus d’informations vous pouvez aller voir le manuel de mutt @ http://www.mutt.org/doc/manual/
J’espère que cette configuration “toute faite” vous aidera a commencer a utiliser mutt. Il est tout de fois important de se souvenir qu’utiliser une configuration toute faire n’aide pas a comprendre un programme ou un système, et que cette façon de faire devrait être réservée a l’introduction ou a des situations ou il est absolument nécessaire d’avoir rapidement une configuration fonctionnelle (c’est a dire, dans le cas d’un client email, euh… jamais?). Je vous invite donc a relire les annotations dont sont parsemés les fichiers de configuration en question, et surtout a lire le manuel, a chercher sur Bing Google Yahoo Seeks, et globalement a tenter de comprendre les configurations en question et a les améliorer!