blog/2025
1
Fork 0
Code Issues Activity

Récupération d'articles d'archives

Browse Source
This commit is contained in:
Richard Dern
2026-03-29 03:00:47 +02:00
parent 060119c91c
commit ecc25fe7cf
592 changed files with 17498 additions and 8153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
content/interets/informatique/2012/02/06/creation-de-sa-propre-autorite-de-certification/index.md Normal file
View File

@@ -0,0 +1,280 @@
---
comments_url: https://com.richard-dern.fr/post/514
date: '2012-02-06 03:23:00'
dossier:
- Créer son propre Cloud
links:
- lang: fr
name: Page d'origine sur Archive.org
url: https://web.archive.org/web/20120618100138/http://ingnu.fr/2012/02/06/creation-de-sa-propre-autorite-de-certification/
tags:
- Autorité
- Certification
- Certificats
- OpenSSL
title: Création de sa propre autorité de certification
weather:
humidity: 57
illuminance: 0.0
precipitations: false
pressure: 1027.9
source:
- open-meteo
temperature: -10.4
wind_direction: 73
wind_speed: 8.7
weight: 3
---
J'avais [initialement](https://web.archive.org/web/20120618100138/http://ingnu.fr/2012/02/05/installer-et-configurer-un-serveur-dns/) prévu d'aborder dans un troisième article la configuration d'un serveur mail, mais il fallait d'abord que j'explique comment mettre en place une autorité de certification, puisque nous allons nous en servir dans la configuration du serveur mail, mais aussi pour bien d'autres services que nous verrons ultérieurement.
À l'issue de cet article, vous aurez à disposition une série de scripts qui vous permettront de mettre rapidement et facilement en place des certificats pour tous types d'applications.
L'autorité de certification et les certificats vous permettront de chiffrer les données qui vont transiter sur votre cloud personnel.
Ainsi, si une personne malintentionnée cherchait à espionner ce qui transite entre votre propre machine et votre serveur, elle ne pourrait pas exploiter les données qu'elle récolterait.
C'est une solution fiable, même si tout chiffrement peut être "cassé".
Il faut simplement garder à l'esprit que vous n'êtes pas une banque, et que les données que vous allez stocker sur votre serveur n'ont de valeur que pour vous.
Personne ne cherchera donc à passer des semaines ou des mois à casser le chiffrement de vos certificats...
Notice : En revanche, ils seront bien utiles pour chiffrer les données qui transitent sur votre réseau.
Important : [VeriSign](https://web.archive.org/web/20120618100138/http://www.verisign.com/ssl/index.html?tid=gnps)
Créons tout d'abord un répertoire dédié à nos scripts :
```bash
mkdir -p /scripts/certificate_authority
```
Vérifions ensuite que nous disposons bien du paquet nécessaire :
```bash
apt-get install openssl
```
Nous allons créer les premiers certificats, matérialisant l'autorité de certification.
Les certificats spécifiques à certains services seront signés par cette autorité.
Pour commencer, on va se créer un fichier de configuration personnalisé :
```bash
cp /etc/ssl/openssl.cnf /scripts/certificate_authority/
cd /scripts/certificate_authority
nano openssl.cnf
```
On édite ce fichier pour y modifier les variables suivantes :
- Dans la catégorie *[CA_default]*, mettez les valeurs suivantes :
```text
dir = /scripts/certificate_authority
certs = $dir/
crl_dir = $dir/
database = $dir/index.txt
new_certs_dir = $dir/
certificate = $dir/ca.crt
serial = $dir/current_serial
crlnumber = $dir/current_crl
crl = $dir/crl.pem
private_key = $dir/ca.key
RANDFILE = $dir/.rand
```
- Dans la catégorie *[req_distinguished_name]*, renseignez les valeurs suivantes :
- *countryName_default*
- *stateOrProvinceName_default*
- *localityName_default*
- *0.organizationName_default*
- *emailAddress_default*
Enregistrez puis fermez ce fichier.
On va ensuite créer le fichier *create_ca*, qui aura pour but de créer l'autorité de certification.
L'autorité de certification n'est à créer qu'une seule fois, mais le fait de créer un script pour le faire permettra, en cas de besoin, de retrouver les commandes nécessaires.
À noter que nous allons créer un certificat dont la validité est de 10 ans (3650 jours).
```bash
nano create_ca
```
```text
#!/bin/bash
base=`dirname $0`
echo "Étape 1 : Création de la clé"
openssl genrsa -des3 -out "$base/ca.key" 1024
echo "Étape 2 : Génération de la demande de certificat"
openssl req -config "$base/openssl.cnf" -new -key "$base/ca.key" -out "$base/ca.csr"
echo "Étape 3 : Génération du certificat"
openssl x509 -days 3650 -signkey "$base/ca.key" -in "$base/ca.csr" -req -out "$base/ca.crt"
chmod 0400 ca.key
```
```bash
chmod 700 create_ca
```
Cette dernière commande nous assure que personne à part *root* ne peut exécuter ce fichier.
Ce que nous allons faire immédiatement :
```bash
./create_ca
```
Après vous avoir demandé un mot de passe (qu'il est impératif de renseigner), quelques questions vont vous être posées.
La plupart contient déjà les réponses pré-replies dans le fichier *openssl.cnf* que nous avons édité plus tôt.
Seule la variable *Organizational Unit Name* est à spécifier (mettez ce que vous voulez, par exemple "*Certificate Authority*"), et la variable *Common Name*, qui devrait contenir votre nom de domaine principal.
Une fois la commande exécutée et les variables spécifiées, trois nouveaux fichiers ont été créés dans le répertoire de travail (*/scripts/certificate_authority*) : *ca.csr* (la demande de certificat), *ca.crt* (le certificat principal) et *ca.key* (la clé privée).
On peut désormais créer de nouveaux certificats, à l'aide d'un nouveau script :
```bash
nano make_request
```
```text
#!/bin/bash
app=$1
domain=$2
base=`dirname $0`
if [ "$app" == "" ]
then
echo "Vous devez spécifier un nom d'application ou de service"
exit
fi
if [ "$domain" == "" ]
then
echo "Vous devez spécifier un nom de domaine"
exit
fi
if [ ! -d "$base/$app" ]
then
mkdir "$base/$app"
fi
echo "Étape 1 : Création de la clé"
openssl genrsa -des3 -out "$base/$app/$domain.key" 1024
echo "Étape 2 : Création de la demande de certificat"
openssl req -config "$base/openssl.cnf" -new -key "$base/$app/$domain.key" -out "$base/$app/$domain.csr"
echo "Souhaitez-vous créer une clé sans mot de passe ? (o/n) [n]"
read answer
if [ $answer = o -o $answer = O ]
then
cp "$base/$app/$domain.key" "$base/$app/$domain.key-withpass"
openssl rsa -in "$base/$app/$domain.key-withpass" -out "$base/$app/$domain.key"
chmod 0440 "$base/$app/$domain.key-withpass"
fi
chmod 0440 "$base/$app/$domain.key"
```
```bash
chmod +x ./make_request
```
L'objectif de ce script va être de générer une demande de certificat pour une application donnée et un domaine donné.
Cela nous permettra de générer des certificats différents selon les applications et les domaines, mais il est tout à fait possible (bien que déconseillé) de générer un seul certificat et de s'en servir dans toutes nos applications.
Ce script s'utilisera de la manière suivante :
```bash
./make_request <application> <domaine>
```
Ce script va également nous permettre de créer des clés sans mot de passe, ce qui sera utile avec apache.
Créons ensuite le script qui va nous permettre de demander la signature d'une demande précédente :
```text
nano sign_request
```
```text
#!/bin/bash
app=$1
domain=$2
base=`dirname $0`
serial=0
if [ "$app" == "" ]
then
echo "Vous devez spécifier un nom d'application ou de service"
exit
fi
if [ "$domain" == "" ]
then
echo "Vous devez spécifier un nom de domaine"
exit
fi
if [ ! -d "$base/$app" ]
then
echo "Aucun certificat n'a été généré pour l'application spécifiée"
exit
fi
if [ ! -f "$base/$app/$domain.csr" ]
then
echo "Aucun certificat n'a été généré pour le domaine spécifié"
exit
fi
if [ -f "$base/current_serial" ]
then
serial=`cat "$base/current_serial"`
fi
serial=$(($serial+1))
openssl x509 -req -days 3650 -in "$base/$app/$domain.csr" -CA "$base/ca.crt" -CAkey "$base/ca.key" -set_serial $serial -out "$base/$app/$domain.crt"
echo "$serial" > "$base/current_serial"
echo "Souhaitez-vous supprimer la requête initiale ? ($domain.csr) (o/n) [o]"
read answer
if [ "$answer" != "n" -a "$ans" != "N" ]
then
rm "$base/$app/$domain.csr"
fi
```
```bash
chmod 700 sign_request
```
La syntaxe est la même que précédemment :
```bash
./sign_request <application> <domaine>
```
La signature du certificat va générer un fichier portant l'extension *.crt* : c'est celui-ci qui sera notamment utilisé à travers les applications.
La procédure pour créer un certificat valide est donc la suivante.
Nous admettrons pour l'exemple que nous travaillons avec apache.
```bash
./make_request apache exemple.fr
./sign_request apache exemple.fr
```
Cela aura pour conséquence de créer un répertoire apache dans le répertoire */scripts/certificate_authority*, qui contiendra vos certificats, demandes, et clés spécifiques à apache.
Vous disposez désormais d'un ensemble complet d'outils pour générer facilement les certificats dont vous aurez besoin plus tard, et notamment lors de la mise en place du serveur mail, prochaine étape de la création de votre cloud personnel.

723
content/interets/informatique/2012/02/06/installation-de-son-propre-serveur-mail/index.md Normal file
View File

@@ -0,0 +1,723 @@
---
comments_url: https://com.richard-dern.fr/post/515
date: '2012-02-06 17:53:00'
dossier:
- Créer son propre Cloud
links:
- lang: fr
name: Page d'origine sur Archive.org
url: https://web.archive.org/web/20120621224105/http://ingnu.fr/2012/02/06/installation-de-son-propre-serveur-mail/
tags:
- Amavis
- ClamAV
- Dovecot
- IMAP
- Postfix
- SMTP
title: Installation de son propre serveur mail
weather:
humidity: 46
illuminance: 1393.7
precipitations: false
pressure: 1028.7
source:
- open-meteo
temperature: -7.7
wind_direction: 65
wind_speed: 9.5
weight: 4
---
Le quatrième article de la [nouvelle rubrique](https://web.archive.org/web/20120621224105/http://ingnu.fr/category/creer-son-propre-cloud/) va donc traiter de l'installation de son propre serveur mail, élément indispensable de la chaîne de communication.
Il existe déjà de nombreux tutoriels sur Internet, parfois très bien faits, parfois incomplets ou inadaptés.
Je ne prétends pas que mon article sera mieux que les autres, j'espère seulement qu'il trouvera son public.
Notre serveur mail devra être sécurisé : nous ferons appel au chiffrement, ainsi qu'à diverses applications permettant de filtrer spam et virus, le plus efficacement possible, sans pour autant bloquer les correspondances légitimes (il m'est arrivé que certaines personnes utilisant un serveur SMTP wanadoo (sic) se retrouvent bloquées par mon serveur, à cause d'un non respect du protocole SMTP...).
Nous utiliserons le serveur SMTP [postfix](https://web.archive.org/web/20120621224105/http://www.postfix.org/), aux côtés duquel tournera le serveur IMAP [dovecot](https://web.archive.org/web/20120621224105/http://dovecot.org/).
Le filtrage sera confié à [Spamassassin](https://web.archive.org/web/20120621224105/http://spamassassin.apache.org/), [amavis](https://web.archive.org/web/20120621224105/http://www.amavis.org/) et [clamav](https://web.archive.org/web/20120621224105/http://www.clamav.net/lang/en/).
Nous aurons recourt à une base de données de type [MySQL](https://web.archive.org/web/20120621224105/http://www.mysql.com/).
Même si vous ne gérerez qu'un seul domaine, virtualiser les utilisateurs et les domaines n'est pas plus consommateur de ressources : MySQL (ou tout autre serveur de bases de données, j'aurai pu traiter de [postgreSQL](https://web.archive.org/web/20120621224105/http://www.postgresql.org/) s'il ne me manquait pas de l'expérience) sera installé tôt ou tard, autant l'utiliser tout de suite.
Et si par la suite vous acquérez un autre domaine et que vous vouliez proposer un service mail pour ce domaine, vous n'aurez pas de migration fastidieuse à effectuer.
Lorsque debconf vous demandera un mot de passe pour MySQL (et par extension, chaque fois que vous devrez saisir un mot de passe dans les prochains articles), vous devriez considérer utiliser un [générateur de mot de passe](https://web.archive.org/web/20120621224105/http://randompassword.com/).
En utilisant un tel outil, vous pourrez générer des mots de passe complexes, de la longueur et de la complexité que vous voulez.
Sous debian donc, on installe les paquets suivants :
```bash
apt-get install amavisd-new arj bzip2 cabextract clamav clamav-freshclam clamav-daemon cpio dovecot-imapd gzip lha mysql-server p7zip pax postfix postfix-mysql postfix-pcre ripole rpm spamassassin tar unrar-free unzip xz-utils zip zoo
```
Outre postfix, dovecot, l'anti-virus et l'anti-spam, on installe également quelques utilitaires appelés par amavis/clamav pour analyser les pièces jointes aux futurs mails qui seront envoyés ou reçus par votre serveur.
On passe ensuite à la configuration de MySQL.
## MySQL
debconf vous a probablement demandé de choisir un mot de passe pour l'utilisateur root (celui de MySQL).
Vous devez maintenant créer un nouvel utilisateur pour la première base de données que nous allons créer, et qui sera exploitée par notre serveur mail.
```bash
mysql -u root -pVotreMotDePasse
```
Notice : *-p*
Saisissez alors les commandes suivantes, en remplaçant *NouveauMotDePasse* par un nouveau mot de passe, différent de celui de root (là encore, pensez à utiliser le générateur de mots de passe) :
```text
CREATE USER 'MailServer'@'localhost' IDENTIFIED BY 'NouveauMotDePasse';
GRANT USAGE ON * . * TO 'MailUser'@'localhost' IDENTIFIED BY 'NouveauMotDePasse';
CREATE DATABASE IF NOT EXISTS `MailServer` ;
GRANT ALL PRIVILEGES ON `MailServer` . * TO 'MailServer'@'localhost';
```
Nous avons créé un nouvel utilisateur nommé *MailServer*, et une base de données dans laquelle il a tout privilège.
Créons ensuite la structure :
```text
USE MailServer;
```
```text
CREATE TABLE `access_sender` (
`source` varchar(128) CHARACTER SET utf8 NOT NULL DEFAULT '',
`access` varchar(128) CHARACTER SET utf8 NOT NULL DEFAULT '',
`created` datetime NOT NULL,
`modified` datetime NOT NULL,
`active` tinyint(1) NOT NULL DEFAULT '1',
UNIQUE KEY `source` (`source`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COMMENT='Virtual Sender Restrictions';
CREATE TABLE `aliases` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`source` varchar(255) CHARACTER SET utf8 NOT NULL,
`destination` varchar(255) CHARACTER SET utf8 NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
CREATE TABLE `domains` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8 NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`email` varchar(255) CHARACTER SET utf8 NOT NULL,
`password` varchar(32) CHARACTER SET utf8 NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
quit;
```
Nous avons créé respectivement la table qui contiendra les adresses emails toujours autorisées à nous envoyer quelque chose, quelle que soit la politique de filtrage de notre postfix, la table contenant les futurs alias, celle contenant les domaines et enfin celle qui contiendra nos utilisateurs.
La base de données est configurée, nous pouvons passer à la suite.
## Postfix
Pour que Postfix utilise la base de données que l'on vient de créer, il faut créer quelques fichiers de configuration que nous allons placer dans le répertoire */etc/postfix/mysql* :
```bash
/etc/init.d/postfix stop
mkdir /etc/postfix/mysql
```
Créez ensuite les fichiers suivants (n'oubliez pas de renseigner à chaque fois la variable *password* avec le mot de passe que vous avez attribué à l'utilisateur *MailServer*) :
```bash
cd /etc/postfix/mysql
nano alias.cf
```
```text
user = MailServer
password =
hosts = 127.0.0.1
dbname = MailServer
query = SELECT destination FROM aliases WHERE source='%s'
```
```bash
nano domains.cf
```
```text
user = MailServer
password =
hosts = 127.0.0.1
dbname = MailServer
query = SELECT 1 FROM domains WHERE name='%s'
```
```bash
nano email2email.cf
```
```text
user = MailServer
password =
hosts = 127.0.0.1
dbname = MailServer
query = SELECT email FROM users WHERE email='%s'
```
```bash
nano maps.cf
```
```text
user = MailServer
password =
hosts = 127.0.0.1
dbname = MailServer
query = SELECT 1 FROM users WHERE email='%s'
```
```bash
nano senders_whitelist.cf
```
```text
user = MailServer
password =
hosts = 127.0.0.1
dbname = MailServer
query = SELECT access FROM access_sender WHERE source='%s' AND active = '1'
```
Nous venons simplement de créer les fichiers permettant de communiquer avec les tables créées précédemment.
Modifions ensuite la configuration principale de postfix, à commencer par le fichier *main.cf*.
Nous allons créer une nouvelle configuration en partant de rien, on va donc déplacer le fichier d'origine et en créer un nouveau :
```bash
cd ../
mv main.cf main.cf.orig
nano main.cf
```
Copiez-y ensuite la configuration suivante :
```text
mynetworks = 127.0.0.0/8
# Dovecot settings
virtual_transport = dovecot
dovecot_destination_recipient_limit = 1
# MySQL settings
virtual_mailbox_domains = mysql:/etc/postfix/mysql/domains.cf
virtual_mailbox_maps = mysql:/etc/postfix/mysql/maps.cf
virtual_alias_maps = mysql:/etc/postfix/mysql/alias.cf,mysql:/etc/postfix/mysql/email2email.cf
# SASL
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth
smtpd_sasl_auth_enable = yes
# TLS
smtp_tls_CAfile = /scripts/certificate_authority/ca.crt
smtpd_tls_CAfile = /scripts/certificate_authority/ca.crt
smtpd_tls_cert_file = /scripts/certificate_authority/exemple.fr.crt
smtpd_tls_key_file = /scripts/certificate_authority/exemple.fr.key
smtpd_tls_received_header = yes
tls_random_source = dev:/dev/urandom
smtp_tls_security_level = may
smtpd_tls_security_level = may
smtp_use_tls = yes
smtpd_use_tls = yes
smtpd_tls_auth_only = no
#smtpd_tls_wrappermode = yes
smtpd_tls_loglevel = 1
# Filtering
content_filter = smtp-amavis:[127.0.0.1]:10024
receive_override_options = no_address_mappings
# Restrictions
unknown_address_reject_code = 554
unknown_hostname_reject_code = 554
unknown_client_reject_code = 550
unverified_sender_reject_code = 554
smtpd_helo_required = yes
strict_rfc821_envelopes = yes
smtpd_recipient_restrictions =
reject_non_fqdn_sender,
reject_unknown_sender_domain,
reject_non_fqdn_recipient,
reject_unknown_recipient_domain,
permit_mynetworks,
permit_sasl_authenticated,
reject_unauth_destination,
check_helo_access pcre:/etc/postfix/helo_checks.pcre,
reject_invalid_helo_hostname,
reject_non_fqdn_helo_hostname,
check_sender_access mysql:/etc/postfix/mysql/senders_whitelist.cf,
reject_rbl_client zen.spamhaus.org
```
Important : *main.cf*
Il faut créer le fichier *helo_checks.pcre*.
En utilisant les expressions rationnelles, cela permettra à postfix d'opérer un filtrage sur la commande *helo* du protocole SMTP.
```bash
nano helo_checks.pcre
```
```text
/^localhost$/ 550 Don’t use localhost
/^(base\.)?(exemple\.fr|exemple2\.fr)$/ 550 Don’t use my own domain/hostname
/^\[?88\.190\.15\.133\]?$/
550 Spammer comes to me \
Greets me with my own IP \
His mail I shall not see.
/^[0-9.-]+$/
550 Your software is not RFC 2821 compliant: \
EHLO/HELO must be a domain or an \
address-literal (IP enclosed in brackets)
```
On modifie ensuite le fichier *master.cf* :
```text
nano master.cf
```
Dé-commentez la ligne (située en début du fichier) :
```text
smtps inet n - - - - smtpd
```
Et rajoutez les lignes suivantes :
```text
dovecot unix - n n - - pipe
flags=DRhu user=vmail:vmail argv=/usr/lib/dovecot/deliver -d ${recipient}
```
```text
smtp-amavis unix - - n - 2 smtp
-o smtp_data_done_timeout=1200
-o smtp_send_xforward_command=yes
-o disable_dns_lookups=yes
-o max_use=20
```
```text
127.0.0.1:10025 inet n - n - - smtpd
-o content_filter=
-o smtpd_restriction_classes=
-o smtpd_delay_reject=no
-o smtpd_client_restrictions=permit_mynetworks,reject
-o smtpd_helo_restrictions=
-o smtpd_sender_restrictions=
-o smtpd_recipient_restrictions=permit_mynetworks,reject
-o smtpd_data_restrictions=reject_unauth_pipelining
-o smtpd_end_of_data_restrictions=
-o mynetworks=127.0.0.0/8
-o smtpd_error_sleep_time=0
-o smtpd_soft_error_limit=1001
-o smtpd_hard_error_limit=1000
-o smtpd_client_connection_count_limit=0
-o smtpd_client_connection_rate_limit=0
-o receive_override_options=no_header_body_checks,no_unknown_recipient_checks
-o local_header_rewrite_clients=
```
Ces lignes servent à interfacer dovecot et amavis avec postfix.
Il nous reste encore à créer les certificats.
```bash
/scripts/certificate_authority/make_request postfix mail.exemple.fr
```
Notice : *Common Name*
*mail.exemple.fr*
Signez ensuite le certificat :
```bash
/scripts/certificate_authority/sign_request postfix mail.exemple.fr
```
La configuration de postfix étant terminée, on s'occupe des filtres.
## Filtres
```bash
/etc/init.d/amavis stop
/etc/init.d/clamav-daemon stop
/etc/init.d/clamav-freshclam stop
adduser clamav amavis
adduser amavis clamav
```
Important : *amavis*
*clamav*
*clamav*
*amavis*
On édite ensuite la configuration de amavis :
```bash
nano /etc/amavis/conf.d/15-content_filter_mode
```
Dé-commentez les lignes dans ce fichier pour qu'il ressemble à ceci :
```text
use strict;
@bypass_virus_checks_maps = (
\%bypass_virus_checks, \@bypass_virus_checks_acl, \$bypass_virus_checks_re);
@bypass_spam_checks_maps = (
\%bypass_spam_checks, \@bypass_spam_checks_acl, \$bypass_spam_checks_re);
1; # ensure a defined return
```
Puis :
```bash
nano /etc/amavis/conf.d/20-debian_defaults
```
Vers la ligne 68, assurez-vous d'avoir les directives de configuration suivantes :
```text
$final_virus_destiny = D_DISCARD; # (data not lost, see virus quarantine)
$final_banned_destiny = D_BOUNCE; # D_REJECT when front-end MTA
$final_spam_destiny = D_BOUNCE;
$final_bad_header_destiny = D_PASS; # False-positive prone (for spam)
```
On bloque ainsi totalement les virus, mais on laisse passer le spam (qui sera tagué par la suite) pour éviter de supprimer du courrier légitime.
On continue :
```bash
nano /etc/amavis/conf.d/50-user
```
```text
use strict;
#
# Place your configuration directives here. They will override those in
# earlier files.
#
# See /usr/share/doc/amavisd-new/ for documentation and examples of
# the directives you can use in this file
#
$sa_spam_subject_tag = '***** SPAM ***** ';
$spam_quarantine_to = undef;
$sa_tag_level_deflt = undef;
$final_spam_destiny=D_PASS;
@lookup_sql_dsn = (
['DBI:mysql:database=MailServer;host=127.0.0.1;port=3306',
'MailServer',
'MotDePasse']);
$sql_select_policy = 'SELECT name FROM domains WHERE CONCAT("@",name) IN (%k)';
#------------ Do not modify anything below this line -------------
1; # ensure a defined return
```
On peut maintenant démarrer les services :
```bash
/etc/init.d/amavis start
/etc/init.d/clamav-daemon start
/etc/init.d/clamav-freshclam start
```
## Dovecot
```bash
/etc/init.d/dovecot stop
cd /etc/dovecot
```
Configurons tout d'abord la connexion au serveur MySQL :
```bash
mv dovecot-sql.conf dovecot-sql.conf-orig
nano dovecot-sql.conf
```
```text
driver = mysql
connect = host=127.0.0.1 dbname=MailServer user=MailServer password=MotDePasse
default_pass_scheme = PLAIN-MD5
password_query = SELECT email AS user, password FROM users WHERE email='%u'
```
Comme d'habitude, pensez à changer le mot de passe, et mettez celui de l'utilisateur MySQL *MailServer*.
Enregistrez puis fermez, avant de modifier la configuration principale :
```bash
mv dovecot.conf dovecot.conf-orig
nano dovecot.conf
```
```text
base_dir = /var/run/dovecot
protocols = imaps managesieve
ssl = yes
ssl_cert_file = /scripts/certificate_authority/dovecot/mail.exemple.fr.crt
ssl_key_file = /scripts/certificate_authority/dovecot/mail.exemple.fr.key
ssl_key_password = MotDePasse
mail_location = maildir:/var/vmail/%d/%n/Maildir
mail_uid = vmail
mail_gid = vmail
mail_privileged_group = mail
protocol imap {
}
protocol managesieve {
login_executable = /usr/lib/dovecot/managesieve-login
mail_executable = /usr/lib/dovecot/managesieve
}
protocol lda {
postmaster_address = postmaster@exemple.fr
auth_socket_path = /var/run/dovecot/auth-master
mail_plugins = sieve
}
auth_executable = /usr/lib/dovecot/dovecot-auth
auth default {
mechanisms = plain login
passdb sql {
args = /etc/dovecot/dovecot-sql.conf
}
userdb static {
args = uid=5000 vid=5000 home/var/vmail/%d/%n
}
user = root
socket listen {
master {
path = /var/run/dovecot/auth-master
mode = 0600
user = vmail
group = vmail
}
client {
path = /var/spool/postfix/private/auth
mode = 0660
user = postfix
group = postfix
}
}
}
plugin {
sieve=/var/vmail/%d/%n/Maildir/sieve/.dovecot.sieve
sieve_dir=/var/vmail/%d/%n/Maildir/sieve
sieve_global_path = /etc/sieve/sieve.global
}
```
Lorsque nous allons générer le certificat et la clé à utiliser avec dovecot, vous aurez la possibilité de créer une clé sans mot de passe.
Si vous choisissez de créer une clé sans mot de passe, commentez la ligne *ssl_key_password = MotDePasse*.
Dans le cas contraire, indiquez le mot de passe utilisé lors de la génération du certificat.
Quelques répertoires vont devoir être créés :
```bash
mkdir /etc/sieve
mkdir /var/vmail
```
On génère les certificats :
```bash
/scripts/certificate_authority/make_request dovecot mail.exemple.fr
/scripts/certificate_authority/sign_request dovecot mail.exemple.fr
```
On créé ensuite l'utilisateur *vmail* :
```bash
addgroup vmail --gid 5000
adduser --system --disabled-password --no-create-home --disabled-login --uid 5000 --gid 5000 vmail
chown -R vmail:vmail /var/vmail
```
On peut désormais redémarrer dovecot :
```bash
/etc/init.d/dovecot restart
```
Nous avons configuré dovecot pour utiliser le plugin *sieve/managesieve*.
Cela nous permettra plus tard de mettre en place des filtres pour la messagerie.
Créons tout de même le fichier de configuration de base pour sieve, dont le rôle va être simplement de déplacer le spam dans le bon répertoire :
```bash
nano /etc/sieve/sieve.global
```
```text
require ["fileinto"];
# rule:[Spam]
if header :contains "Subject" "***** SPAM *****"
{
fileinto "Spam";
}
```
## Quelques tests
Installez le paquet [telnet](https://web.archive.org/web/20120621224105/http://packages.debian.org/fr/squeeze/telnet) si vous ne l'avez pas déjà :
```bash
apt-get install telnet
telnet localhost 25
ehlo exemple.fr
quit
```
Vous devriez avoir une sortie console qui ressemble à ceci :
```text
Trying ::1...
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 minerva.localdomain ESMTP Postfix
ehlo exemple.fr
250-minerva.localdomain
250-PIPELINING
250-SIZE 10240000
250-VRFY
250-ETRN
250-STARTTLS
250-AUTH PLAIN LOGIN
250-ENHANCEDSTATUSCODES
250-8BITMIME
250 DSN
```
Procédez de même avec le port 465, la sortie doit être la même.
Pour tester le serveur IMAP, nous devons créer un premier domaine, puis un premier utilisateur du domaine :
```bash
mysql -u root -pMotDePasse
```
```text
USE MailServer;
INSERT INTO domains (name) VALUES ('exemple.fr');
INSERT INTO users (email, password) VALUES ('test@exemple.fr', MD5('MotDePasse'));
quit;
```
On peut ensuite tester le serveur IMAP :
```bash
openssl s_client -connect localhost:993
```
La dernière ligne affichée devrait ressembler à ceci :
```text
* OK [CAPABILITY IMAP4rev1 LITERAL+ SASL-IR LOGIN-REFERRALS ID ENABLE AUTH=PLAIN AUTH=LOGIN] Dovecot ready.
```
Suite à quoi, écrivez :
```text
A LOGIN test@exemple.fr MotDePasse
```
La fin de la ligne suivante devrait afficher "Logged in".
Concluez la session avec :
```text
a5 LOGOUT
```
Nous testerons plus tard les anti-virus et anti-spam.
Pour l'heure, nous avons une dernière chose à régler.
## Firewall
```bash
nano /scripts/firewall
```
Entre les lignes :
```text
##### Configuration personnalisée #####
```
Et :
```text
##### Fin : Configuration personnalisée #####
```
Rajoutez les lignes suivantes :
```text
${IPT} -A SERVICES -p tcp --dport 25 -j ACCEPT
${IPT} -A SERVICES -p tcp --dport 465 -j ACCEPT
```
Ce sont les deux ports à ouvrir pour que votre serveur SMTP puisse communiquer avec l'extérieur (et vice-versa).
Important : ```text
${IPT} -A SERVICES -p tcp --dport 993 -j ACCEPT
```
Cette commande permet d'ouvrir le port 993, qui est le port attribué au serveur IMAP sécurisé.
Nous n'utiliserons donc pas le port habituel, le 143.
## DNS
Dernière étape de l'installation de notre serveur mail, la modification de la configuration de notre serveur DNS pour sa prise en compte.
On édite donc le fichier de définition de notre zone :
```bash
nano /etc/bind/db.exemple.fr
```
Et on rajoute à la fin (sans oublier de modifier l'identifiant de l'enregistrement !) :
```text
IN MX 10 mail.exemple.fr.
mail IN A 1.1.1.1
```
Et on redémarre bind :
```bash
/etc/init.d/bind9 restart
```
C'est aussi simple que ça !
La prochaine étape consistera à installer un serveur web sécurisé, et quelques applications utiles, dont un client de messagerie pour jouer avec le serveur mail que l'on vient d'installer.