{{indexmenu_n>30}}

## Permettre aux machines d'envoyer des mails

Les machines peuvent avoir besoin d'envoyer des mails :

* Proxmox pour prévenir de l'échec d'un backup
* Debian pour faire une synthèse des mises à jour de sécurité réalisées
* etc

Pour ce faire, on va configurer et configurer Postfix sur les machines, et lui demander d'utiliser le serveur mail de Picasoft comme relai SMTP. 

<bootnote>Postfix est un [[technique:old:etudes:mail:serveurs_de_mail:mta|MTA]] (*Mail Transfer Agent*). Voir aussi [[technique:old:etudes:mail:protocoles:smtp|SMTP]].</bootnote>

De la sorte, la machine pourra envoyer ses mails vers n'importe quelle adresse mail.

Ce tutoriel peut être adapté pour n'importe quel serveur mail ; ici on suppose le service de soumission de mails Picasoft est accessible en `STARTTLS` sur `mail.picasoft.net:587`.

<bootnote learn>Opportunistic TLS (Transport Layer Security) refers to extensions in plain text communication protocols, which offer a way to upgrade a plain text connection to an encrypted (TLS or SSL) connection instead of using a separate port for encrypted communication. Several protocols use a command named "STARTTLS" for this purpose. *[Source](https://en.wikipedia.org/wiki/Opportunistic_TLS)*</bootnote>

On commence par installer les paquets `libsasl2-modules` et `postfix` :

```
apt install libsasl2-modules postfix
```

<bootnote>Si on vous demande une configuration par défaut, choisissez "pas de configuration".</bootnote>

Il nous faut trois choses :

* Indiquer à Postfix d'utiliser le serveur mail de Picasoft avec `STARTTLS` comme relai
* Indiquer les informations d'authentification au serveur mail de Picasoft (qui, pour rappel, [[technique:adminsys:mail:config:ldap:start|utilise le serveur LDAP pour l'authentification]]).
* Ré-écrire l'adresse de l'émetteur (de base, ça serait `root@<hostname>`)

### Configuration Postfix pour relayer les mails locaux

On va commencer par configurer Postfix.

On pourrait se contenter d'envoyer directement les mails depuis la machine locale, sauf que comme notre serveur mail local n'est pas connu, ni configuré, sans SPF, DKIM, etc..., et bien on risque de se faire méchamment rejeter. 

<bootnote>Au contraire, le serveur mail de Picasoft (qui tourne sur `monitoring`) est béton ! C'est pourquoi on s'authentifie sur lui pour envoyer le mail à travers (d'où le terme de **relai**) plutôt que directement depuis le Postfix local.</bootnote>

On crée le fichier `/etc/postfix/main.cf`, avec les informations suivantes :

<bootnote>Remplacer `bob` par le nom de la machine concernée (`pica01`, `pica02`, etc).</bootnote>

```
alias_maps = hash:/etc/aliases
alias_database = hash:/etc/aliases
# Hostname of the machine
myhostname = bob.picasoft.net
myorigin = bob.picasoft.net
# Domains "owned" by the machine (ie itself)
mydestination = bob.picasoft.net, bob, localhost.localdomain, localhost

# Only authorize local mail sending (won't relay external emails)
mynetworks_style = host

# Rewrite senders
sender_canonical_maps = regexp:/etc/postfix/sender_canonical

# Rewrite FROM header
smtp_header_checks = regexp:/etc/postfix/header_check

# Relay via Picasoft mail server
relayhost = mail.picasoft.net:587

# TLS parameters
smtp_use_tls = yes
smtp_sasl_auth_enable = yes
smtp_sasl_security_options =
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt

mailbox_size_limit = 0
recipient_delimiter = +
# Only listen to localhost, ignore external requests
inet_interfaces = 127.0.0.1
default_transport = relay
inet_protocols = all
```

Remarquer les lignes :

```
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
sender_canonical_maps = regexp:/etc/postfix/sender_canonical
smtp_header_checks = regexp:/etc/postfix/header_check
```

C'est ce qu'on va configurer ensuite.

<bootnote web>Pour des précisions sur les *tables* Postfix (`hash`, `regexp`, etc), voir [la documentation officielle](http://www.postfix.org/DATABASE_README.html).</bootnote>

### Authentification

On indique les informations d'authentification au serveur mail de Picasoft dans le fichier `/etc/postfix/sasl_passwd`. On lui donne ce contenu :

```
mail.picasoft.net <utilisateur>:<password>
```

On a préalablement créé un utilisateur LDAP `utilisateur` qui a les droits pour envoyer des mails.

<bootnote warning>Même si c'est un peu plus long, il est recommandé de créer un utilisateur par machine virtuelle. Ainsi, on saura juste avec l'expéditeur de quelle machine a été expédié le mail.</bootnote>

<bootnote>Voir [[technique:adminsys:ldap:add_mail|cette page]] pour la partie de création du compte LDAP.</bootnote>

On créé ensuite une *table* correspondant au fichier d'authentification : 

```bash
sudo postmap /etc/postfix/sasl_passwd
```

On protège les fichiers :

```bash
sudo chown postfix:postfix /etc/postfix/sasl_passwd*
sudo chmod 600 /etc/postfix/sasl_passwd*
```

### Ré-écriture de l'émetteur

On édite le fichier `/etc/postfix/sender_canonical` et on ajoute la ligne suivante :

```
/.+/ <utilisateur>@picasoft.net
```

Ainsi, tous les envois locaux, depuis n'importe quel utilisateur, seront ré-écrits avec l'utilisateur `<utilisateur>@picasoft.net`.

<bootnote warning>Il est important que l'utilisateur utilisé pour se connecter au relai soit le même que l'adresse mail d'envoi : une vérification est faite au niveau du serveur mail de Picasoft pour s'assurer que les deux concordent.</bootnote>


On créé ensuite une *table* correspondant au fichier de ré-écriture : 

```bash
sudo postmap /etc/postfix/sender_canonical
```

<bootnote>On peut tester que tout fonctionne avec la commande suivante :

```
sudo postmap -q random_login regexp:/etc/postfix/sender_canonical
```

Si la commande renvoie `<utilisateur>@picasoft.net`, alors la ré-écriture fonctionne !
</bootnote>
On protège les fichiers :

```bash
sudo chown postfix:postfix /etc/postfix/sender_canonical*
sudo chmod 640 /etc/postfix/sender_canonical*
```

Enfin, on crée le fichier `/etc/postfix/header_check`, qu'on remplit avec :

```
/^From\:.*$/ REPLACE From: <utilisateur>@picasoft.net
```

L'idée est de remplacer le header `FROM`, s'il existe, par la bonne adresse ré-écrite, sans le nom d'utilisateur du compte local qui a envoyé le mail devant. C'est pour des raisons de lisibilité dans la boîte de réception.

Puis, pareil que précédemment :

```bash
sudo postmap /etc/postfix/header_check
sudo chown postfix:postfix /etc/postfix/header_check*
sudo chmod 640 /etc/postfix/header_check*
```

### Finalisation

On active et on démarre Postfix :

```
sudo systemctl enable postfix
sudo systemctl start postfix
```

On vérifie que tout s'est bien passé :

```
systemctl status postfix
```

À ce stade, tous les mails envoyés depuis la machine (via `sendmail` par exemple) qui sont à destination d'un domaine non local sont relayés via le serveur de mail de Picasoft.

### Test

Le programme `mail` permet d'envoyer des mails. Par exemple :

```
mail -s "Test relai Postfix" <ton adresse etu>
```

Supposons que j'envoie depuis le compte local `qduchemi` vers l'adresse `quentin.duchemin@etu.utc.fr`.

Normalement, voici ce qui devrait se passer :

* Postfix accepte l'envoi, car local
* Postfix ré-écrit l'émetteur `qduchemi` en `<machine>@picasoft.net`
* Postfix ré-écrit le header `FROM` en `<machine>@picasoft.net`
* Comme le domaine de sortie `etu.utc.fr` est différent de `<machine>.picasoft.net`, Postfix comprend qu'il doit relayer via le serveur mail `mail.picasoft.net`
* Il se sert des identifiants donnés pour le compte `bob`, dans `sasl_auth`
* Le serveur mail de Picasoft reçoit une demande d'authentification, et l'accepte
* Ce même serveur reçoit alors une soumission de mail. Il compare l'émetteur (champ `FROM`) et le compte utilisé pour l'authentification. Ce sont les mêmes, il valide.
* Il relait le mail au serveur de destination (`utc.fr`).

Dans mon cas, pour mes tests, j'ai envoyé un mail de toutes les machines en même temps :

{{ :technique:infrastructure:machines_virtuelles:postfix_relay_vms.png |}}

Tout fonctionne ! :-D