Mail_Server_Install/README.md

# Installation Serveur Mail 

## Installation de Postfix 
```console 
root@serveur:~# apt-get install postfix-mysql 
```
### Verification du contenu de master.cf

```console 
root@serveur:~# vim /etc/postfix/master.cf
```

Dans le fichier (master.cf) il faut verifier que la premiere ligne ne contienne que un seul "n". La ligne doit ressembler a ceci:
```console
smtp inet n - - - - smtpd
```

### Creation de la base de donnees MySQL 
* On cree une base de donnees **postfix**, on ajoute un utilisateur postfix en passant par les privileges. Bien noter le mot de passe generer.
* On cree les trois tables avec le code suivant: 
    ~~~~sql 
        USE postfix;

        CREATE TABLE `domaines` (
          `domaine` varchar(255) NOT NULL default '',
          `etat` tinyint(1) NOT NULL default '1',
          PRIMARY KEY  (`domaine`)
        ) ENGINE=MyISAM;
        
        CREATE TABLE `comptes` (
          `email` varchar(255) NOT NULL default '',
          `password` varchar(255) NOT NULL default '',
          `quota` int(10) NOT NULL default '0',
          `etat` tinyint(1) NOT NULL default '1',
          `imap` tinyint(1) NOT NULL default '1',
          `pop3` tinyint(1) NOT NULL default '1',
          PRIMARY KEY  (`email`)
        ) ENGINE=MyISAM;
        
        CREATE TABLE `alias` (
          `source` varchar(255) NOT NULL default '',
          `destination` text NOT NULL,
          `etat` tinyint(1) NOT NULL default '1',
          PRIMARY KEY  (`source`)
        ) ENGINE=MyISAM;       
    ~~~~

### Edition des 5 fichiers de configuration suivants:
* Contenu de `mysql-virtual_domaines.cf`

    ```text
        hosts = 127.0.0.1
        user = postfix
        password = **Mot de passe Mysql Postfix**
        dbname = postfix
        select_field = 'virtual'
        table = domaines
        where_field = domaine
        additional_conditions = AND etat=1
    ```
* Contenu de  `mysql-virtual_comptes.cf`

    ```text
        hosts = 127.0.0.1
        user = postfix
        password = **Mot de passe Mysql Postfix**
        dbname = postfix
        table = comptes
        select_field = CONCAT(SUBSTRING_INDEX(email,'@',-1),'/',SUBSTRING_INDEX(email,'@',1),'/')
        where_field = email
        additional_conditions = AND etat=1
    ```

* Contenu de `mysql-virtual_aliases.cf`

    ```text
        hosts = 127.0.0.1
        user = postfix
        password = **Mot de passe Mysql Postfix**
        dbname = postfix
        table = alias
        select_field = destination
        where_field = source
        additional_conditions = AND etat=1
    ```
    
* Contenu de `mysql-virtual_aliases_comptes.cf`    

    ```text
        hosts = 127.0.0.1
        user = postfix
        password = **Mot de passe Mysql Postfix**
        dbname = postfix
        table = comptes
        select_field = email
        where_field = email
        additional_conditions = AND etat=1
    ```
    
* Contenu de `mysql-virtual_quotas.cf`    

    ```text
        hosts = 127.0.0.1
        user = postfix
        password = **Mot de passe Mysql Postfix**
        dbname = postfix
        table = comptes
        select_field = quota
        where_field = email
    ```
    
### Ajout du groupe et de l'utilisateur `vmail`

```console 
root@serveur:~# groupadd -g 5000 vmail 
root@serveur:~# useradd -g vmail -u 5000 vmail -d /var/spool/vmail -m 
```

### Configuration du `main.cf`

Editer le `main.cf`

```console 
root@serveur:~# vim /etc/postfix/main.cf 
```

~~~~ini
# Bannière afficher lorsqu'on se connecte en SMTP sur le port 25
smtpd_banner = $myhostname ESMTP $mail_name (Debian/GNU)

# Service qui envoie des notifications "nouveau message"
biff = no

# Desactive la commande SMTP VRFY. Arrête certaine technique pour avoir des adresses email
disable_vrfy_command = yes

# Impose au client SMTP de démarrer la session SMTP par une commande Helo (ou ehlo)
smtpd_helo_required = yes

# Avec le courier local ça ajoute .NDD aux adresses incomplètes (seulement le nom d'hote)
append_dot_mydomain = no

# Le nom de la machine du système de messagerie
# Par défaut c'est host.domain.tld mais on peut mettre un reverse dns
myhostname = DOMAINNAME (Not reverse DNS)

# Le domaine utilisé par defaut pour poster les message local
myorigin = REVERSE_DNS

# Liste des domaines pour lequel le serveur doit accepter le courrier
mydestination = REVERSE_DNS, localhost.localdomain, localhost

# Pour effectuer des livraisons de courrier avec un relay (ici non)
relayhost =

# Liste des réseaux locaux autorisés
mynetworks = 127.0.0.0/8, IP_PUBLIQUE_SERVEUR

# Taille des boîtes au lettre (0 = illimité)
mailbox_size_limit = 0

# Séparateur entre le nom d'utilisateur et les extensions d'adresses
recipient_delimiter = +

# Interfaces réseaux à écouter (ici toutes)
inet_interfaces = all

# Gestion des boites mails virtuelle
# Contient les fichiers qui permettent de relier postfix  mysql
virtual_alias_maps = mysql:/etc/postfix/mysql-virtual_aliases.cf,mysql:/etc/postfix/mysql-virtual_aliases_comptes.cf
virtual_mailbox_domains = mysql:/etc/postfix/mysql-virtual_domaines.cf
virtual_mailbox_maps = mysql:/etc/postfix/mysql-virtual_comptes.cf

# Le dossier ou seront contenu les mails (=home de l'user vmail)
virtual_mailbox_base = /var/spool/vmail/

# L'id du groupe et de l'utilisateur vmail créé précédement
virtual_uid_maps = static:5000
virtual_gid_maps = static:5000

# Créer un dossier par comte email
virtual_create_maildirsize = yes

# A activer si vous souhaitez ajouter des quotas
virtual_mailbox_extended = yes

# Impose les limites au niveau des mails, dans notre cas aucune
virtual_mailbox_limit_maps = mysql:/etc/postfix/mysql-virtual_quotas.cf

# Ajouter une limite sur la taille des messages pour les boites virtuelles
virtual_mailbox_limit_override = yes
virtual_maildir_limit_message = "La boite mail de votre destinataire est pleine, merci de reessayez plus tard."
virtual_overquota_bounce = yes

# adresses d'expedition
smtpd_sender_restrictions =
        permit_mynetworks,
        warn_if_reject reject_unverified_sender

# adresses de destination
smtpd_recipient_restrictions =
        permit_mynetworks,
        reject_unauth_destination,
        reject_non_fqdn_recipient

# client
smtpd_client_restrictions =
        permit_mynetworks
~~~~

### Modification des droits sur les fichiers de configuration
```console 
root@serveur:~# chmod 640 /etc/postfix/mysql-virtual_*.cf
root@serveur:~# chgrp postfix /etc/postfix/mysql-virtual_*.cf
```

### Restart postfix
```console 
root@serveur:~# /etc/init.d/postfix restart 
```
## Ajout d'un compte

### Insertion d'un nouveau domaine dans la base de donnees
Selectionner la table `domaines`et inserer un nouveau domaine
Ex: "domaine.tld" et mettre l'etat a "1".

### Insertion d'un nouvel utilisateur
Une fois la base de donnees `postfix`selectionnee (normalement c'est deja le cas), il faut executer le code SQL suivant:
~~~~sql 
    INSERT INTO `comptes`(`email`, `password`, `quota`, `etat`, `imap`, `pop3`) VALUES ('test@domaine.tld', ENCRYPT('motdepasse'), '0', '1', '1', '1');
~~~~

### Test par Telnet (Creation des repertoires mail par la meme occasion)

Executer la commande suivante:
```console 
root@serveur:~# telnet 127.0.0.1 25
```
Puis dans Telnet executer les commandes suivantes:
```text 
ehlo domaine.tld
mail from:<peuimporte@domaine.tld>
rcpt to:<test@domaine.tld> (l'email doit figurer dans la table comptes)
data (Puis ecrire le body du mail, ensuite faire Enter et terminer par ".")
quit (Pour sortir de Telnet)
```



## Courier

### Installation de `Courier`
```console 
root@serveur:~# apt-get install courier-base courier-authdaemon courier-authlib-mysql courier-imap courier-pop
```

### Configuration de `Courier`

Editer `/etc/courier/authdaemonrc`
```console
root@serveur:~# vim /etc/courier/authdaemonrc
```

Modifier la ligne: `authmodulelist = authpam` -> `authmodulelist = authmysql`

Editer `/etc/courier/authmysqlrc`
```console
root@serveur:~# vim /etc/courier/authmysqlrc
```

**Modifier:**
```text
         `MYSQL_USERNAME`
         `MYSQL_PASSWORD`
         `MYSQL_DATABASE` -> postfix
         `MYSQL_USER_TABLE` -> comptes
         `MYSQL_CRYPT_PWFIELD` -> password
         `MYSQL_UID_FIELD` -> 5000
         `MYSQL_GID_FIELD` -> 5000
         `MYSQL_LOGIN_FIELD` -> email
         `MYSQL_HOME_FIELD` -> "/var/spool/vmail"
```         
         
**Commenter:** `MYSQL_NAME_FIELD`         


**Ajouter:** `MYSQL_MAILDIR_FIELD` -> CONCAT(SUBSTRING_INDEX(email,'@',-1),'/',SUBSTRING_INDEX(email,'@',1),'/')

### Redemarrage des services

```console
root@serveur:~# /etc/init.d/courier-authdaemon restart
root@serveur:~# /etc/init.d/courier-pop restart
root@serveur:~# /etc/init.d/courier-imap restart
```



## RoundCube

### Telecharger la derniere version de Roundcube 
Se rendre [ici](https://roundcube.net/) pour telecharger roundcube. 
Creer un VirtualHost sur le serveur Web et l'associer a Roundcube.

### Base de donnees Roundcube 
Creer une base de donnees `roundcube` ajouter un utilisateur (roundcube par exemple) et generer un mot de passe (a conserver pour la suite de l'installation.)

Creer les tables necessaires au bon fonctionnement de Roundcube avec la commande suivante:

```console
root@serveur:~# mysql -u root -p roundcube < /var/www/domaine.tld/roundcube/SQL/mysql.initial.sql
```

### Configuration de Roundcube
Se rendre a l'adresse ou Roundcube est accessible, (par exemple [https://mail.domaine.tld/](https://mail.domaine.tld/)) et rajouter `installer` a la fin de l'url.
Ce qui donnerait par exemple: [https://mail.domaine.tld/installer](https://mail.domaine.tld/installer)

Verifier les options de configuration:
* Mysql Database Roundcube db_addr
* Mysql Database Roundcube db_name
* Mysql Database Roundcube db_user
* Mysql Database Roundcube db_pass

Certaines extentions peuvent manquer, verifier et les installer. (D'autres sont facultatives.)

**NE PAS OUBLIER DE RETIRER LE DOSSIER `installer/` DU REPERTOIRE WEB DE ROUNDCUBE**

## Configuration SPF

SPF - Informer le serveur de reception que l'on est bien le vrai serveur en charge de ce domaine.

Inserer cet enregistrement dans le fichier de configuration DNS de `domaine.tld`:

```dns
@               IN TXT "v=spf1 a mx -all"
```

* Le `a` signifie que les serveurs qui possedent un enregistrement `A` sont des serveurs SMTP autorises.
* Le `mx` signifie que les serveurs qui possedent un enregistrement `MX` sont des serveurs SMTP autorises.

(Il me semble que c'est tout pour le SPF... :/)


## Retirer le header avec l'IP du client

Il peut etre bien de retirer l'IP du client qui s'est connecté au serveur SMTP (autrement dit, le lieu depuis lequel on a envoyé notre email)

Pour ce faire, il faut ajouter cette ligne:

```
  -o header_checks=pcre:/etc/postfix/header_checks
```

juste apres :

```
cleanup   unix  n       -       n       -       0       cleanup
```

Ensuite il faut pas oublier d'installer `postfix-pcre`

```
sudo apt install postfix-pcre
```

Puis restart postfix

```
systemctl restart postfix
```

# Installation Nouvelle Option

Se référer au tuto suivant pour commencer:

https://www.linuxbabe.com/mail-server/setup-basic-postfix-mail-sever-ubuntu


## Gestion des utilisateurs via les utilisateurs unix

Si l'on a choisi d'utiliser les utilisateurs comme facon de gerer les comptes emails, ces derniers ne portent pas comme nom `user@domain.tld` mais plutot `user` ou `user-AT-domain-DOT-tld`.

Pour faire la correspondance entre le user utilisé lors de la connexion et le sender qui va envoyer les emails, il faut definir une correspondance entre les deux.

Les emails peuvent etre envoyés sans faire la correspondance par defaut. Mais si l'on applique la regle
```
  -o smtpd_sender_restrictions=reject_sender_login_mismatch
```

dans le fichier `master.cf` alors il faudra faire la correspondance sinon l'utilisateur ne sera pas autorisé à envoyer des mail avec un sender qui vaut `user@domain.tld` alors que son username est simplement `user`.

Pour faire cette fameuse correspondance, il faut commencer par ajouter deux lignes dans le fichier `main.cf`

```
virtual_alias_domains = romanet.fr
virtual_alias_maps = hash:/etc/postfix/virtual
```

Puis il faut éditer/créer le fichier `/etc/postfix/virtual` et y noter les correspondances que l'on souhaite faire.
Par exemple:

```
user1@romanet.fr user1
```

Ici on précise donc que si un utilisateur se connecte au serveur SMTP avec comme identifiant `user1` il aura le droit d'envoyer des mails avec comme `sender` `user1@romanet.fr`

Il faut ensuite mettre à jour cette sorte de base de deonnées avec la commande suivante:

```
postmap /etc/postfix/virtual
```

Je crois que l'on n'est pas obligé de redémarrer postfix.

## Configuration DKIM

DKIM - Verifier que l'expéditeur est bien celui qu'il prétend être - Signature des mail lors de l'envoi.

DKIM sert a signer les messages pour que la personne qui reçoit (ou plutôr le serveur) soit certain que ce soit bien celui qui prétend être l'expéditeur. En effet, si l'expéditeur n'est pas capable de signer le message ou le signe pas correctement, c'est que ce n'est peut-être pas lui...

Pour mettre en place DKIM il faut une pair de clés, une publique et une privée. La clé privée va signer/chiffrer le message qui sort de notre serveur mail (Postfix).
Le destinataire va pouvoir déchiffrer et vérifier la signature à l'aide de la clé publique. 
Cette clé publique est disponible car on va la publier sur un nenregistrement DNS. 

Seul le propriétaire du nom de domaine peut effectuer des modifications sur les enregistrements DNS, donc seul le propriétaire peut publier une clé publique qui permetra de déchiffrer la signature.

Si le destinataire reçoit un message signé de notre part, il va tenté d'utiliser la clé publique mise à disposition sur le serveur DNS pour vérifier la signature. Si la signature est vérifiée, on est à peu près certain que l'expéditeur est bien celui qu'il prétend être.

### Installation outils

On commence par installer les outils dkim sur le serveur:

```
sudo apt install opendkim-tools opendkim
```

### Génération pair de clés

Puis on génére notre fameuse pair de clés:

```
opendkim-genkey -b 2048 -d romanet.fr -s romanet.fr.dkim
```

Ca va nous fabriquer deux clés:

* romanet.fr.dkim.private
* romanet.fr.dkim.txt

La clé .private sera utilisée par le serveur pour signer les mails, et doit rester bien protégée.
La clé .txt sera publiée dans notre enregistrement DNS

### Configuration - Générale

Ensuite on va editer le fichier de configuration de opendkim `/etc/opendkim.conf`

```
Socket inet:12345@localhost
Syslog yes
UserID opendkim:opendkim
PidFile                 /var/run/opendkim/opendkim.pid
Selector mail
Mode sv
SubDomains yes
AutoRestart yes
Background yes
Canonicalization relaxed/relaxed
DNSTimeout 5
SignatureAlgorithm rsa-sha256
X-Header yes
Logwhy yes

InternalHosts /etc/opendkim/internalhosts
KeyTable /etc/opendkim/keytable
SigningTable refile:/etc/opendkim/signtable

OversignHeaders From

```

Ici on précise le `socket` qui sera utilisé pour communiquer avec postfix sur les signatures.
On demande à DKIM de verifier les signatures `v` et de signer nos mails `s` avec `Mode sv`
On déclare également trois fichiers:

* InternalHosts
* KeyTable
* SigningTable

Nous allons éditer ces fichiers.

Nous allons commencer par `/etc/opendkim/internalhosts`

```
mail.romanet.fr
romanet.fr
192.168.0.0/255.255.255.0
```

Ce fichier contient les IP ou domaines que OpenDKIM doit plutôt signer que vérifier

Ensuite nous éditons `/etc/opendkim/keytable`

```
romanet.fr romanet.fr:mail:/etc/opendkim/keys/romanet.fr.dkim.private
```

Ce fichier contient une table de correspondance entre le nom de la clé et la clé privée utilisée pour signer les mails.

Si par exemple on a plusieurs domaines, on aurait besoin de plusieurs clés, OpenDKIM a besoin de savoir où trouvée la clé privée pour tel domaine.

Le mot `mail` présent dans ce fichier n'est autre que le `SELECTOR`, il ne s'agit pas d'un sous-domaine ou autre. Certains utilisent comme `SELECTOR` une année ou `JAN2016`.

On termine par éditer le fichier: `/etc/opendkim/signtable`

```
*@romanet.fr romanet.fr
```

Ce fichier sert à associer une adresse email (un champ `FROM:`) avec un un ou plusieurs `SELECTOR`.
Nous dans notre cas, on va utiliser la même clé pour tous les expéditeurs sous romanet.fr voilà pourquoi on utilise une astérisque ou `wild card`.

### Placer les clés dans un endroit protégé

Avant d'oublier on va créer un dossier où l'on va ranger nos clés, ce dossier on l'a déjà mentionné dans un fichier de configuration plus haut.

```
mkdir /etc/opendkim/keys/
```

Puis on déplace nos clés:

```
mv romanet.fr.dkim.* /etc/opendkim/keys/
```

Enfin on modifie les droits:

```
chown opendkim:opendkim /etc/opendkim/keys/ -R
chmod 0700 /etc/opendkim/keys
chmod 0600 /etc/opendkim/keys/romanet.fr.dkim.private
```

### Publier la clé dans un enregistrement DNS

Voici à quoi doit resembler l'nenregistrement:

```
mail._domainkey.romanet.fr. 1800 IN TXT ( "v=DKIM1; h=sha256; k=rsa; "
          "p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0mbJPd+M8qOpPNqJdEMvrghdK66x72NRqK0gHnNpWgeCPURxnUKIA0NQVP/5UtxNL2JXF2TMDzg7WTYQN3ER1f5GwSQyBKqQ9g4ApfbrgHVedHnVQJBIh83o6XP+57KH39qerUrq0RVRDy5O/k4BO+7q7Z6TXz9yRC0fIb8PKUCCCtpfDg+gFzpq5XKzB2AjCxIlx3HnZ6HyDo"
          "Y0jTRo+kK8HnBKYhurPIe85AuvZXtU51avXOpn+j4MO08toJqNKPIzgs6J1erhcDe+op5vl2T8O4Nw77w0hu/YCVg/XpXtyh7sHizYKMGkfn1Go+BknxOcase8C/A3840k3KbpLQIDAQAB" )

```

On repère:
* Notre `SELECTOR` (mail)
* Le`_domainkey` qui doit être écrit ainsi.
* Notre séquence DKIM entre parentheses

Entre parentheses on repère trois champs:

* `v` qui correspond à la version du protocol DKIM
* `k` qui correspond à une liste d'algorithmes qui peuvent permettre de lire la signature
* `p` qui correspond à la clé publique (en base 64)

Ces valeurs sont disponibles dans le fichier `/etc/opendkim/keys/romanet.fr.dkim.txt`
Attention de ne pas tout copier, lors de la génération des clés au debut, on n'a pas précisé le domaine, le selecteur etc. La ligne proposée dans le `.txt` n'est pas tout à fait adaptée à notre configuration. Prendre uniquement ce qui se trouve entre les parentheses.

### Informer Postfix que l'on souhaite utiliser DKIM

Dans le fichier `/etc/default/opendkim` on va déjà dé-commenter la ligne suivante:

```
SOCKET="inet:12345@localhost" # listen on loopback on port 12345
```

Qui va permettre à DKIM de communiquer sur le port 12345

Ensuite, on va éditer le fichier de configuration de postfix: `/etc/postfix/main.cf`

```
# - Connexion DKIM socket
milter_protocol = 6
milter_default_action = accept
smtpd_milters = inet:localhost:12345
non_smtpd_milters = $smtpd_milters

```

Avec ça, postfix va pouvoir communiquer avec DKIM sur le port 12345. Les deux services sont reliés !

Après toutes ces étapes, on n'oublie pas de restart `opendkim` sur le serveur mail.

### Verifier que DKIM fonctionne

Si DKIM fonctionne un envoi d'email à un compte google nous le dira.
On ira verifier la validation du DKIM en allant afficher le mail original depuis Gmail.
S'il n'y a pas de trace de DKIM, c'est qu'il y a un problème quelque part.

Avec un `journalctl -xe` ou un `tail /var/log/syslog` on peut en apprendre plus sur notre problème.
Si l'on a une erreur du style:
```
systemd[1]: opendkim.service: Can't open PID file /run/opendkim/opendkim.pid (yet?) after start: Operation not permitted
```

On peut essayer de la resoudre en retirant le champ `PIDFile` du fichier `/lib/systemd/system/opendkim.service` en le commentant.

Après cette opération il faut d'un part recharger notre list de daemon:

```
sudo systemctl daemon-reload
```

Et ensuite redémarrer (ou du coup démarrer) OpenDKIM:

```
sudo systemctl restart opendkim
```

Voilà pour DKIM ;)

## DMARC

C'est visiblement juste une politique de traitement des email louches...
Si on met en place DMARK, et que quelqu'un reçoit un mail de mon domaine (mais que je n'ai pas envoyé, qui a été envoyé par quelqu'un qui usurpe mon nom de domain), voilà ce qui se passera:
Si j'ai mis en place SPF et DKIM, le serveur qui va recevoir ce mail, va se rendre compte que l'authentification n'est pas bonne. Ce serveur mail qui a recu ce mail louche, va donc pouvoir m'informer de cet incident et enventuellement, saura quoi faire de cet email.

DMARC tout seul n'est pas une sécurité, mais un moyen de remonter des infos pour cesser une usurpation par exemple.

On peut simplement mettre en place DMARK avec un enregistrement DNS comme suit:

```
_dmarc.romanet.fr. IN TXT "v=DMARC1; p=quarantine; pct=100; rua=mailto:postmaster@romanet.fr"
```

Ici on definie la politique à suivre au serveur qui recevra un mail louche: quarantine
On indique aussi qui informer de cet incident : postmaster@romanet.fr

Petite info, ici on ne parle que SPF, DKIM et DMARC **outbound** et non **inbound**.
On cherche ici à faire en sorte qu'à l'envoi nos messages soient bien accueillis.
Il faudrait également mettre en place des SPF, DKIM et DMARC **inbound** pour s'assurer que l'on ne reçoit pas de SPAM dans les boite du domaine dont on s'occupe. 





Liens tutos:

https://www.malekal.com/installer-configurer-postfix-spf-dkim-dmarc/

https://petermolnar.net/article/howto-spf-dkim-dmarc-postfix/#postfix

https://words.bombast.net/postfix-with-spf-dkim-and-dmarc/

https://datacadamia.com/marketing/email/postfix/opendkim


## Configuration Roundcube (Nouvelle option)

### Installation Apache PHP MySQL

Installer Apache et ses modules

```
sudo apt install apache2
sudo apt install php libapache2-mod-php php-mysql
sudo apt install mariadb-server
```

Configuration de mariadb

```
sudo mysql_secure_installation
```

Si un mot de passe est demandé pour l'installation, comme il n'y en a pas pour le moment, il faut simplement faire `Enter`

Puis definir un mot de passe et continuer la configuration.

### Installation des modules necessaires à Roundcube

```
sudo apt install php7.4 libapache2-mod-php php7.4-gd php7.4-common php7.4-json php7.4-json php-imagick php7.4-imap php7.4-xml php7.4-opcache php7.4-mbstring php7.4-curl php7.4-zip php7.4-bz2 php7.4-intl php7.4-intl
```

### Creation de la base de données Roundcube

Cette base de données est necessaire au fonctionnement de Roundcube.
Mais contrairement à l'ancienne methode que j'utilisais, on ne va pas utiliser cette base de données pour se s'identifier sur la Webmail. Cette base de données va servir à Roundcube pour se souvenir des emails etc.

```
sudo mysql -u root -p
```

Attention sur les instruction suivantes à bien modifier le mot de passe `password` de la requète SQL.
Et attention à bien se souvenir de ce mot de passe, on va en avoir besoin pour la suite !

```
CREATE DATABASE roundcubedb DEFAULT CHARACTER SET utf8;
GRANT ALL PRIVILEGES ON roundcubedb.* TO 'rounduser'@'localhost' IDENTIFIED BY 'password';
FLUSH PRIVILEGES;
exit;
```


### Télécharger et installer Roundcube

Verifier sur le site de Roundcube où se trouve la dernière version:
https://roundcube.net/download/

Liste de étapes suivantes:

* Téléchargement de RoundCube
* Extraction de l'archive
* Création du dossier `romanet.fr` dans le répertoire de apache
* Déplacement du dossier RoundCube vers le dossier apache
* Modification du propriétaire (apache)
* Modification des permissions sur le dossier


```
wget https://github.com/roundcube/roundcubemail/releases/download/1.4.11/roundcubemail-1.4.11-complete.tar.gz
tar xvf roundcubemail-1.4.11-complete.tar.gz
sudo mkdir /var/www/romanet.fr/
sudo mv roundcubemail-1.4.11 /var/www/romanet.fr/roundcube
sudo chown -R www-data:www-data /var/www/romanet.fr/roundcube
sudo chmod 755 -R /var/www/romanet.fr/roundcube
```

Puis, il faut créer le necessaire dans notre base de données RoundCube grâce à un fichier de configuration présent dans le dossier d'installation RoundCube:

```
mysql -u rounduser -p roundcubedb < /var/www/romanet.fr/roundcube/SQL/mysql.initial.sql
```

Création d'un VirtualHost:

```
<VirtualHost *:80>
  ServerName new-mail.romanet.fr
  DocumentRoot /var/www/romanet.fr/roundcube/

  <Directory />
    Options FollowSymLinks
    AllowOverride All
  </Directory>

  <Directory /var/www/romanet.fr/roundcube/>
    Options FollowSymLinks MultiViews
    AllowOverride All
    Order allow,deny
    allow from all
  </Directory>

  ErrorLog ${APACHE_LOG_DIR}/new-mail.romanet.fr_error.log
  CustomLog ${APACHE_LOG_DIR}/new-mail.romanet.fr_access.log combined

</VirtualHost>

```

On oublie pas d'activer le site et eventuellement de désactiver le site par defaut
Puis on redémarre apache

On peut également ajouter un VirtualHost sur le reverse proxy si on en utilise un, et lui ajouter un certificat SSL avec `certbot`

Bien entendu, il faudra ajouter un enregistrement DNS pour ce site si ce n'est pas déjà fait.

### Configuration initiale de Roundcube

Lorsque tout cela est fait, on se rend sur la page de notre webmail en visitant par exemple:

https://mail.romanet.fr/installer

Sur cette page on va renseigner toutes les informations qui sont nécessaires à RoundCube pour communiquer avec nos serveurs IMAP et SMTP. 

Si la connexion au serveur SMTP ne fonctionne pas en STARTTLS (587) ce n'est pas grave on vera cela après.

On termine la config et on passe à la suite.

### Configuration plus avancée de RoundCube

#### Modofication du fichier `config/config.inc.php`

On peut ajouter ces lignes:

```
$config['mail_domain'] = '%t';
$config['useragent'] = '';

```

* La première ligne informe RoundCube que le domaine des nouvelles adresses email est le suivant `%t` à savoir juste le nom de domaine configuré.
* La seconde retire le User-Agent utilisé lors de l'envoi des email via RoundCube.

Pour la première ligne (mail_domain), il faut savoir que même si l'utilisateur existe déjà sur le système Linux, il n'existe peut-être pas dans la base de données de RoundCube.
Et lors de la "création" de cet utilisateur (lors de sa première connexion à RoundCube) un domain va lui être attribué.
Si l'on effectue pas ce changement de configuration, RoundCube risque d'attribuer une adresse email de type `user@localhost` au lieu de `user@romanet.fr`.


#### Modofication du fichier `config/defaults.inc.php`

Pour faire fonctionner RoundCube avec le serveur SMTP en STARTTLS il faut ajouter le préfix `tls://` devant l'adresse du serveur SMTP. Cela doit resembler à la ligne suivante:

`$config['smtp_server'] = 'tls://localhost';`

Si même après avoir ajouté le préfix `tls://` RoundCube envoie une erreur du type:
```
Erreur SMTP (220) : échec d’authentification.
```
et que les logs de postfix `/var/log/mail.log` nous renvoient:
```
connect from localhost[127.0.0.1]
lost connection after STARTTLS from localhost[127.0.0.1]
disconnect from localhost[127.0.0.1] ehlo=1 starttls=1 commands=2
```
Alors on va ajouter une information dans la configuration pour dire à RoundCube de passer la vérification du certificat (il me semble):

```
$config['imap_conn_options'] = array(
'ssl' => array(
'verify_peer' => false,
'verfify_peer_name' => false,
),
);
$config['smtp_conn_options'] = array(
'ssl' => array(
'verify_peer' => false,
'verify_peer_name' => false,
),
);
```

Penser à supprimer ou commenter les lignes déjà présentes qui ne sont pas autant détaillées concernant `imap_conn_options` et `smtp_conn_options`.

Attention, il semble que les informations de ce fichier peuvent être écrasées lors d'une mise à jour de RoundCube, si tel est le cas, penser et prendre le temps de retourner modifier ce fichier en cas d'erreurs.