Mercredi 28 février 2018

Debian 9 serveur web (nginx+php7+mariadb) + serveur de messagerie (postfix dovecot dkim spf dmarc rainloop spamassassin clamav fail2ban)

KVM Debian 9 serveur (nginx+php7+mariadb)

Debian 9

Package: 4 GB Mémoire, 2 CPU, 30 GB SSD, 100 Mbps
Selected Location: Paris
Debian 9 64
Livraison : vps-26381 93.115.96.97

  • Domaine : xoyize.xyz
  • IPv4 du serveur : 93.115.96.97
  • IPv6 du serveur : 2a03:75c0:35:670d::1
  • Certificats : Let’s Encrypt

Première connexion SSH

Via SSH

ssh root@93.115.96.97 Màj  

apt update && apt upgrade

Modifier hostname

hostnamectl set-hostname --static vps26381

Modifier /etc/hosts

127.0.0.1       localhost
93.115.96.97    xoyize.xyz vps26381


# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Vérifications

hostname
	vps26381
hostname --fqdn
	xoyize.xyz

Installer les divers outils

apt install rsync curl tmux jq figlet git dnsutils -y

Locales

Locales : fr_FR.UTF-8

dpkg-reconfigure locales
Generating locales (this might take a while)...
  fr_FR.UTF-8... done
Generation complete.

TimeZone

Europe/Paris

dpkg-reconfigure tzdata
Current default time zone: 'Europe/Paris'
Local time is now:      Wed Feb 14 06:41:55 CET 2018.
Universal Time is now:  Wed Feb 14 05:41:55 UTC 2018.

root

Modifier le mot de passe root

passwd root

Création utilisateur

Utilisateur xoyan

useradd -m -d /home/xoyan/ -s /bin/bash xoyan

Mot de passe xoyan

passwd xoyan

Visudo pour les accès root via utilisateur xoyan

apt install sudo -y #installé par défaut sur certaines distributions
echo "xoyan     ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

Déconnexion puis connexion ssh en mode utilisateur

ssh xoyan@93.115.96.97

DNS OVH

Configuration des champs DNS domaine xoyize.xyz

$TTL 3600
@	IN SOA dns106.ovh.net. tech.ovh.net. (2018021102 86400 3600 3600000 300)
         IN NS     ns106.ovh.net.
         IN NS     dns106.ovh.net.
         IN MX 10  xoyize.xyz.
         IN A      93.115.96.97
         IN AAAA   2a03:75c0:35:670d::1
*        IN CNAME  xoyize.xyz.

Vérifier que les enregistrements MX de la configuration DNS pointent vers le serveur.

dig +short MX xoyize.xyz
	10 xoyize.xyz.

OpenSSH avec clé

OpenSSH

connexion avec clé
sur l'ordinateur de bureau Générer une paire de clé curve25519-sha256 (ECDH avec Curve25519 et SHA2) nommé kvm-vps-26381 pour une liaison SSH avec le serveur KVM.

ssh-keygen -t ed25519 -o -a 100 -f ~/.ssh/kvm-vps-26381

Envoyer la clé publique sur le serveur KVM

scp ~/.ssh/kvm-vps-26381.pub xoyan@93.115.96.97:/home/xoyan/

sur le serveur KVM On se connecte

ssh xoyan@93.115.96.97

Copier le contenu de la clé publique dans /home/$USER/.ssh/authorized_keys

$ cd ~

Sur le KVM ,créer un dossier .ssh

pwd  #pour vérifier que l'on est sous /home/$USER
mkdir .ssh
cat /home/$USER/kvm-vps-26381.pub >> /home/$USER/.ssh/authorized_keys

et donner les droits

chmod 600 /home/$USER/.ssh/authorized_keys

effacer le fichier de la clé

rm /home/$USER/kvm-vps-26381.pub

Modifier la configuration serveur SSH

sudo nano /etc/ssh/sshd_config

Modifier

Port = 55026
PermitRootLogin no
PasswordAuthentication no

session SSH ne se termine pas correctement lors d'un "reboot" à distance
Si vous tentez de redémarrer/éteindre une machine distance par ssh, vous pourriez constater que votre session ne se termine pas correctement, vous laissant avec un terminal inactif jusqu’à l’expiration d’un long délai d’inactivité. Il existe un bogue 751636 à ce sujet. Pour l’instant, la solution de contournement à ce problème est d’installer :

sudo apt install libpam-systemd                #Installer par défaut sur debian 9

cela terminera la session ssh avant que le réseau ne tombe.
Veuillez noter qu’il est nécessaire que PAM soit activé dans sshd.

Relancer openSSH

sudo systemctl restart sshd

Accès depuis le poste distant avec la clé privée

ssh -p 55026 -i ~/.ssh/kvm-vps-26381 xoyan@93.115.96.97

Exécution script sur connexion
Exécuter un fichier utilisateur nommé $HOME/.ssh/rc si présent
Pour tous les utilisateurs exécuter un fichier nommé /etc/ssh/sshrc si présent
Installer les utilitaires curl jq figlet

Le batch

nano ~/.ssh/rc
#!/bin/bash

#clear
PROCCOUNT=`ps -Afl | wc -l`  		# nombre de lignes
PROCCOUNT=`expr $PROCCOUNT - 5`		# on ote les non concernées
GROUPZ=`users`
ipinfo=$(curl -s ipinfo.io) 		# info localisation format json
publicip=$(echo $ipinfo | jq -r '.ip')  # extraction des données , installer préalablement "jq"
ville=$(echo $ipinfo | jq -r '.city')
pays=$(echo $ipinfo | jq -r '.country')
cpuname=`cat /proc/cpuinfo |grep 'model name' | cut -d: -f2 | sed -n 1p`

echo "\033[0m\033[1;31m"  
figlet "xoyize.xyz"
echo "\033[0m"
echo "\033[1;35m  \033[1;37mHostname \033[1;35m= \033[1;32m`hostname`
\033[1;35m  \033[1;37mWired Ip \033[1;35m= \033[1;32m`ip addr show eth0 | grep 'inet\b' | awk '{print $2}' | cut -d/ -f1`
\033[1;35m    \033[1;37mKernel \033[1;35m= \033[1;32m`uname -r`
\033[1;35m    \033[1;37mDebian \033[1;35m= \033[1;32m`cat /etc/debian_version`
\033[1;35m    \033[1;37mUptime \033[1;35m= \033[1;32m`uptime | sed 's/.*up ([^,]*), .*/1/' | sed -e 's/^[ \t]*//'`
\033[1;35m       \033[1;37mCPU \033[1;35m= \033[1;32m`echo $cpuname`
\033[1;35m\033[1;37mMemory Use \033[1;35m= \033[1;32m`free -m | awk 'NR==2{printf "%s/%sMB (%.2f%%)\n", $3,$2,$3*100/$2 }'`
\033[1;35m  \033[1;37mUsername \033[1;35m= \033[1;32m`whoami`
\033[1;35m  \033[1;37mSessions \033[1;35m= \033[1;32m`who | grep $USER | wc -l`
\033[1;35m\033[1;37mPublic Ip  \033[1;35m= \033[1;32m`echo $publicip $pays`
\033[0m"
#curl fr.wttr.in/Paris?0

Effacer motd

sudo rm /etc/motd

Déconnexion puis connexion

Nginx PHP7 MariaDb

lemp

Script debian9-compil-nginx-php7.sh pour compiler et installer nginx + php7 sur debian stretch

Définition des chemins et fichiers de configuration nginx
/etc/nginx/conf.d/xoyize.xyz.conf configuration de base du domaine
Création dossier /etc/nginx/conf.d/xoyize.xyz.d/ pour les fichiers de configuration supplémentaires

sudo mkdir -p /etc/nginx/conf.d/xoyize.xyz.d

Déplacer et renommer le fichier de configuration par défaut

sudo mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/xoyize.xyz.conf

Modifier le fichier

sudo nano /etc/nginx/conf.d/xoyize.xyz.conf
server {
    listen 80;
    listen [::]:80;
    root /var/www/ ;
        location ~ \.php$ {
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           fastcgi_pass unix:/run/php/php7.0-fpm.sock;    # PHP7.0
           fastcgi_index index.php;
           include fastcgi_params;
           fastcgi_param SCRIPT_FILENAME $request_filename;
        }

    include conf.d/xoyize.xyz.d/*.conf;

    access_log /var/log/nginx/xoyize.xyz.log;
    error_log /var/log/nginx/xoyize.xyz.log;
}

Recharger

sudo systemctl reload nginx

Activer le service

sudo systemctl enable nginx

Installer le résolveur DNS Unbound

DNS Unbound

Les serveurs DNS sont des machines discutant entre elles afin de se communiquer les correspondances entre nom de domaine et adresses IP.

Passage en mode super utilisateur

sudo -s # ou su

Désinstaller bind

apt remove --purge bind* -y
rm -r /var/cache/bind/

Installation des outils dns et du paquet Unbound :

apt install dnsutils unbound -y

Téléchargement de la liste des serveurs DNS racines :

cd /var/lib/unbound/ && wget ftp://ftp.internic.net/domain/named.cache

Mise en place de cette liste pour le serveur Unbound :

mv named.cache root.hints && chown unbound:unbound root.hints

Les fichiers de configuration sont situés sous /etc/unbound/unbound.conf.d/
root-auto-trust-anchor-file.conf qui est créé par défaut à l’installation

server:
    # The following line will configure unbound to perform cryptographic
    # DNSSEC validation using the root trust anchor.
    auto-trust-anchor-file: "/var/lib/unbound/root.key"

qname-minimisation.conf qui est créé par défaut à l’installation

server:
    # Send minimum amount of information to upstream servers to enhance
    # privacy. Only sends minimum required labels of the QNAME and sets
    # QTYPE to NS when possible.

    # See RFC 7816 "DNS Query Name Minimisation to Improve Privacy" for
    # details.

    qname-minimisation: yes

Ajout d’un fichier de configuration
dns-yan.conf

server:
 interface: 0.0.0.0
 interface: ::0
 access-control: 0.0.0.0/0 allow
 access-control: ::/0 allow
 root-hints: "/var/lib/unbound/root.hints"
 verbosity: 0
 #qname-minimisation: yes

 num-threads: 2
 msg-cache-slabs: 4
 rrset-cache-slabs: 4
 infra-cache-slabs: 4
 key-cache-slabs: 4
 rrset-cache-size: 100m
 msg-cache-size: 50m
 outgoing-range: 465
 so-rcvbuf: 4m
 so-sndbuf: 4m
 port: 53
 do-ip4: yes
 do-ip6: yes
 do-udp: yes
 do-tcp: yes
 do-daemonize: yes
 hide-identity: yes
 hide-version: yes
 harden-glue: yes
 harden-dnssec-stripped: yes
 harden-referral-path: yes
 use-caps-for-id: yes
 prefetch: yes

Redémarrer le service dnsunbound

systemctl restart unbound

Les commandes suivantes ne fonctionneront que si le paquet “dnsutils” est installé sur votre système Debian!

dig @127.0.0.1 xoyize.xyz +short +dnssec
93.115.96.97
A 7 2 3600 20180313112728 20180211112728 28565 xoyize.xyz. c6J6Shp8HFXdzAon8u2q7Am2TPm8ufjslmwyITy803jXxO8sqzF6tkVB SiIiK6q+g0trEPA7iYTUfRTfg5yhhlRikkvZaPjavgpwxA4DBYzPR+HO LQlXDo+N9mh7+pKrWoO/tfSlji3Di08r6C1tMl5LBkLM5DXBPWuD75ka LpI=

Si la commande dig-command a fonctionné, vous pouvez maintenant définir Unbound comme premier résolveur DNS pour votre système de messagerie:

apt install resolvconf -y
echo "nameserver 127.0.0.1" >> /etc/resolvconf/resolv.conf.d/head

Le résultat de la commande

nslookup xoyize.xyz | grep Server

devrait ressembler à ceci:

Server:     127.0.0.1

Vérifier la résolution de nom à partir du serveur :

dig @127.0.0.1 xoyize.xyz
; <<>> DiG 9.10.3-P4-Debian <<>> @127.0.0.1 xoyize.xyz
; (1 server found)
...

La résolution fonctionne

Maintenant, vous disposez de votre propre résolveur DNS.

Mise à jour automatique des serveurs DNS de la racine ,créer un bash

nano /etc/unbound/dnsunbound-update-root-dns.sh
#!/bin/sh

TmpName=$(mktemp)
TmpDiff=$(mktemp)
TmpErr=$(mktemp)
REPORT_EMAIL="admin"
URL="https://www.internic.net/domain/named.cache"

wget -nv $URL -O $TmpName 2> $TmpErr

# On intercepte toute erreur
# et on stoppe le script dans ce cas
# On continue sinon

if [ "$?" -ne 0 ];then
        printf "\nScript was stopped at this point. A manual action may be required.\n" >> $TmpErr
        mail -s "[DNS - $(uname -n)] Root hints file download failed" $REPORT_EMAIL < $TmpErr
        rm $TmpErr
        rm $TmpDiff
        rm $TmpName
        exit 0
else
        rm $TmpErr
        shaTMP=$(sha512sum $TmpName | awk '{print $1}')
        shaHINTS=$(sha512sum /var/lib/unbound/root.hints | awk '{print $1}')

        if [ $shaTMP = $shaHINTS ]; then
        # Si le fichier récupéré est identique à celui
        # utilisé par Unbound, on fait... rien
                rm $TmpName
                exit 0
        else
                printf "A new root hints file was spotted on InterNIC server.\nFile downloaded and old root.hints file replaced.\nHere is the diff:\n\n" > $Tmp$
                diff $TmpName /var/lib/unbound/root.hints >> $TmpDiff
                printf "\n\n" >> $TmpDiff
                mv -f $TmpName /var/lib/unbound/root.hints
                chown unbound: /var/lib/unbound/root.hints
                chmod 644 /var/lib/unbound/root.hints
                sleep 5
                service unbound restart
                printf "Unbound status is $(service unbound status | grep Active | awk '{print $2 " " $3}')\n" >> $TmpDiff
                mail -s "[DNS - $(uname -n)] Update in Root Hints" $REPORT_EMAIL < $TmpDiff
        rm $TmpDiff
        fi
fi
exit 0

Droits en exécution

chmod +x /etc/unbound/dnsunbound-update-root-dns.sh

Planification journalière

crontab -e

Ajouter en fin de fichier

# Mise à jour automatique des serveurs DNS de la racine
50 02 * * * /etc/unbound/dnsunbound-update-root-dns.sh

Certificats SSL letsencrypt (acme)

SSL Letsencrypt

Génération des certificats

/root/.acme.sh/acme.sh --dns dns_ovh --issue --keylength 4096 -d xoyize.xyz -d smtp.xoyize.xyz -d imap.xoyize.xyz -d webmail.xoyize.xyz -d mail.xoyize.xyz -d nc.xoyize.xyz

Certificats

[mercredi 14 février 2018, 08:03:43 (UTC+0100)] Your cert is in  /root/.acme.sh/xoyize.xyz/xoyize.xyz.cer
[mercredi 14 février 2018, 08:03:43 (UTC+0100)] Your cert key is in  /root/.acme.sh/xoyize.xyz/xoyize.xyz.key
[mercredi 14 février 2018, 08:03:43 (UTC+0100)] The intermediate CA cert is in  /root/.acme.sh/xoyize.xyz/ca.cer
[mercredi 14 février 2018, 08:03:43 (UTC+0100)] And the full chain certs is there:  /root/.acme.sh/xoyize.xyz/fullchain.cer

Création des liens sur /etc/ssl/private pour nginx

ln -s /root/.acme.sh/xoyize.xyz/fullchain.cer /etc/ssl/private/xoyize.xyz-fullchain.pem
ln -s /root/.acme.sh/xoyize.xyz/xoyize.xyz.key /etc/ssl/private/xoyize.xyz-key.pem
ln -s /root/.acme.sh/xoyize.xyz/xoyize.xyz.cer /etc/ssl/private/xoyize.xyz-chain.pem
ln -s /root/.acme.sh/xoyize.xyz/ca.cer /etc/ssl/private/xoyize.xyz-ca.pem

Vérification de la mise à jour automatique

crontab -e

	11 0 * * * "/root/.acme.sh"/acme.sh --cron --home "/root/.acme.sh" > /dev/null

NOTE: Sous-domaines webmail.xoyize.xyz -> Rainloop et nc.xoyize.xyz -> Nextcloud

Nginx + SSL + header + diffie-hellmann

ssl
Il faut préalablement demander des certificats (ca+key) SSL pour le domaine auprès d’une autorité de certification (let’s encrypt ou autre)
Le fichier de configuration

sudo nano /etc/nginx/ssl_params
    ssl_certificate /etc/ssl/private/xoyize.xyz-fullchain.pem;
    ssl_certificate_key /etc/ssl/private/xoyize.xyz-key.pem;
    ssl_session_timeout 5m;
    ssl_session_cache shared:SSL:50m;
    ssl_prefer_server_ciphers on;

    # Ciphers with intermediate compatibility
    # https://mozilla.github.io/server-side-tls/ssl-config-generator/?server=nginx-1.6.2&openssl=1.0.1t&hsts=yes&profile=intermediate
    # ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    # ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS';

    # Ciphers with modern compatibility
    # https://mozilla.github.io/server-side-tls/ssl-config-generator/?server=nginx-1.6.2&openssl=1.0.1t&hsts=yes&profile=modern
    # Uncomment the following to use modern ciphers, but remove compatibility with some old clients (android before 5.0, Internet Explorer before 10, ...)
    ssl_protocols TLSv1.2;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256';

Entêtes
Le fichier de configuration

sudo nano /etc/nginx/header_params
    # Quelques explications https://www.alsacreations.com/article/lire/1723-tour-horizon-https-et-en-tetes-de-securite.html
    #HSTS est un dispositif de sécurité par lequel un site web peut déclarer aux navigateurs qu’ils doivent communiquer avec lui en utilisant exclusivement le protocole HTTPS, au lieu du HTTP
    add_header Strict-Transport-Security "max-age=31536000;";
    # Seul le site utilise peut utiliser iFrame
    add_header Content-Security-Policy "frame-ancestors 'self'";
    #se protéger contre le détournement de clic (clickjacking)
    add_header X-Frame-Options "SAMEORIGIN";
    # Empêche les navigateurs de détecter incorrectement les scripts qui ne sont pas des scripts
    add_header X-Content-Type-Options "nosniff";
    # Bloquer les pages à charger lorsqu'elles détectent des attaques XSS
    add_header X-XSS-Protection "1; mode=block";

    #Supprimer les ## des lignes  pour activer la fonction correspondante

    #CSP permet d’autoriser seulement les domaines déclarés à exécuter du script JavaScript, une feuille de style css, etc.
    # Content-Security-Policy : https://openweb.eu.org/articles/content-security-policy
    ## add_header Content-Security-Policy "default-src 'self'";

    # Désactiver les références pour les navigateurs qui ne prennent pas en charge strict-origin-when-cross-origin
    # Referrer-Policy : https://scotthelme.co.uk/a-new-security-header-referrer-policy/
    # Utilise strict-origin-when-cross-origin pour les navigateurs qui le font
    ## add_header Referrer-Policy "no-referrer, strict-origin-when-cross-origin";

Diffie-Hellmann
Générer une clé Diffie-Hellmann
En cryptographie, l’échange de clés Diffie-Hellman, du nom de ses auteurs Whitfield Diffie et Martin Hellman, est une méthode par laquelle deux agents nommés conventionnellement A etB peuvent se mettre d’accord sur un nombre (qu’ils peuvent utiliser comme clé pour chiffrer la conversation suivante) sans qu’un troisième agent appelé D puisse découvrir le nombre, même en ayant écouté tous leurs échanges.

ATTENTION : Génération clé Diffie-Hellmann très très longue en temps , 30 minutes minimum…

Générer une clé

openssl dhparam -out /etc/ssl/private/dh4096.pem -outform PEM -2 4096

Déplacer la clé dans le répertoire

sudo mv dh4096.pem /etc/ssl/private/

Droits pour root

sudo chmod 600 /etc/ssl/private/dh4096.pem

Le fichier de configuration

sudo nano /etc/nginx/dh_param
    # Uncomment the following directive after DH generation
    # > openssl dhparam -out /etc/ssl/private/dh4096.pem -outform PEM -2 4096
    ssl_dhparam /etc/ssl/private/dh4096.pem;

Configuration de base avec SSL et sécurité + letsencrypt (renouvellement)

sudo nano /etc/nginx/conf.d/xoyize.xyz.conf
server {
    listen 80;
    listen [::]:80;

    ## redirect http to https ##
    return  301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name xoyize.xyz;

    ####    Locations
    # On cache les fichiers statiques
    location ~* \.(html|css|js|png|jpg|jpeg|gif|ico|svg|eot|woff|ttf)$ { expires max; }
    # On interdit les dotfiles
    location ~ /\. { deny all; }

    include ssl_params;
    include header_params;
    include dh_param;

    root /var/www/ ;
    index index.php index.html index.htm;
        location ~ \.php$ {
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           fastcgi_pass unix:/run/php/php7.0-fpm.sock;    # PHP7.0
           fastcgi_index index.php;
           include fastcgi_params;
	   fastcgi_param SCRIPT_FILENAME $request_filename;
        }

    include conf.d/xoyize.xyz.d/*.conf;

    access_log /var/log/nginx/xoyize.xyz-access.log;
    error_log /var/log/nginx/xoyize.xyz-error.log;
}

Vérifier

sudo nginx -t

Relancer

sudo systemctl restart nginx

Test redirection http/https avec curl depuis un poste distant

curl -I xoyize.xyz
HTTP/1.1 301 Moved Permanently
Server: nginx/1.13.8
Date: Sun, 11 Feb 2018 12:37:36 GMT
Content-Type: text/html
Content-Length: 185
Connection: keep-alive
Location: https:///

Tester le lien https://xoyize.xyz

Vérification headers https://securityheaders.io
Vérification complète https://observatory.mozilla.org/analyze.html?host=xoyize.xyz

parefeu (iptables V4 V6)

parefeu Iptables

Créer un script pour mettre en place des règles de base.

cd ~
sudo nano parefeu
#!/bin/sh

# Efface toutes les règles en cours. -F toutes. -X utilisateurs
iptables -t filter -F
iptables -t filter -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
#
ip6tables -t filter -F
ip6tables -t filter -X

ip6tables -t mangle -F
ip6tables -t mangle -X

# stratégie (-P) par défaut : bloc tout l'entrant le forward et autorise le sortant
iptables -t filter -P INPUT DROP
iptables -t filter -P FORWARD DROP
iptables -t filter -P OUTPUT ACCEPT
#
ip6tables -t filter -P INPUT DROP
ip6tables -t filter -P FORWARD DROP
ip6tables -t filter -P OUTPUT ACCEPT

# Ne pas casser les connexions etablies
iptables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
#
ip6tables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Autoriser Loopback
iptables -t filter -A INPUT -i lo -j ACCEPT
iptables -t filter -A OUTPUT -o lo -j ACCEPT
#
ip6tables -t filter -A INPUT -i lo -j ACCEPT
ip6tables -t filter -A OUTPUT -o lo -j ACCEPT

# Autoriser icmp
iptables -t filter -A INPUT -p icmp -j ACCEPT
ip6tables -t filter -A INPUT -p icmp -j ACCEPT

# SSH
iptables -t filter -A INPUT -p tcp --dport 55026 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 55026 -j ACCEPT
#
ip6tables -t filter -A INPUT -p tcp --dport 55026 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 55026 -j ACCEPT

# DNS in/out
# /!\ Il faut autoriser le DNS AVANT de déclarer des hosts sinon pas de résolution de nom possible
iptables -t filter -A OUTPUT -p tcp --dport 53 -j ACCEPT
iptables -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT
iptables -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
iptables -t filter -A INPUT -p udp --dport 53 -j ACCEPT
#
ip6tables -t filter -A OUTPUT -p tcp --dport 53 -j ACCEPT
ip6tables -t filter -A OUTPUT -p udp --dport 53 -j ACCEPT
ip6tables -t filter -A INPUT -p tcp --dport 53 -j ACCEPT
ip6tables -t filter -A INPUT -p udp --dport 53 -j ACCEPT

# HTTP + HTTPS
iptables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT

ip6tables -t filter -A INPUT -p tcp --dport 80 -j ACCEPT
ip6tables -t filter -A INPUT -p tcp --dport 443 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 80 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 443 -j ACCEPT

# IMAP SMTP
iptables -t filter -A INPUT -p tcp --dport 993 -j ACCEPT
iptables -t filter -A INPUT -p tcp --dport 587 -j ACCEPT
iptables -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 993 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 587 -j ACCEPT
iptables -t filter -A OUTPUT -p tcp --dport 25 -j ACCEPT

ip6tables -t filter -A INPUT -p tcp --dport 993 -j ACCEPT
ip6tables -t filter -A INPUT -p tcp --dport 587 -j ACCEPT
ip6tables -t filter -A INPUT -p tcp --dport 25 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 993 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 587 -j ACCEPT
ip6tables -t filter -A OUTPUT -p tcp --dport 25 -j ACCEPT

fichier exécutable :

sudo chmod +x parefeu

Vous pourrez le tester en l’exécutant directement en ligne de commande.

sudo -s
./parefeu

En cas d’erreur, redémarrez le serveur, les règles seront oubliées et vous permettront de reprendre la main.
En revanche, si les tests s’avèrent concluants, ajoutez le lancement des règles iptables au démarrage.
Après avoir exécuté le script précédent,vérifier la présence des règles

iptables -L
ip6tables -L

Lancement du parefeu au démarrage

apt install iptables-persistent

Faut-il enregistrer les règles IPv4 actuelles ? OUI
Faut-il enregistrer les règles IPv6 actuelles ? OUI
Les tables sont enregistrés sous /etc/iptables/ , rules.v4 pour IPv4 et rules.v6 pour IPv6
Sauvegarde/Restauration manuelle des régles iptables

iptables-save > /etc/iptables/rules.v4
ip6tables-save > /etc/iptables/rules.v6
iptables-restore < /etc/iptables/rules.v4
ip6tables-restore < /etc/iptables/rules.v6

En cas de modification pouvez sauver les nouvelles règles du pare-feu

dpkg-reconfigure iptables-persistent

Sauvegarde

On trouvera dans le lien ci-dessus,tout le nécessaire pour installer les éléments pour un “serveur distant”
Le “serveur de sauvegarde” exécute une tâche planifiée
Les sauvegardes seront stockées sur le “serveur de sauvegarde”

Mises à jour de sécurité Debian

Rendre automatique les mises à jour de sécurité Debian en utilisant cron-apt.

apt install cron-apt

Création du fichier security.sources.list utilisé par cron-apt et qui ne contiendra que le(s) dépôt(s) de sécurité Debian.

	grep security /etc/apt/sources.list > /etc/apt/security.sources.list

On édite le fichier de configuration de cron-apt sous /etc/cron-apt/config pour y ajouter les lignes suivantes.

APTCOMMAND=/usr/bin/apt-get
OPTIONS="-o quiet=1 -o Dir::Etc::SourceList=/etc/apt/security.sources.list"
MAILTO="hostmaster@xoyize.xyz"
MAILON="always"

Ne pas oublier de définir l’adresse de messagerie MAILTO

Par défaut, cron-apt télécharge les mise à jour mais ne les installe pas.
Pour déclencher la mise à jour automatique après téléchargement , modifier le fichier /etc/cron-apt/action.d/3-download

nano /etc/cron-apt/action.d/3-download

et supprimer le paramètre -d dans la ligne suivante.

dist-upgrade -y -o APT::Get::Show-Upgraded=true

Lancer un test

cron-apt

Vous devriez recevoir un message de ce type

CRON-APT RUN [/etc/cron-apt/config]: Tue Feb 20 07:48:32 CET 2018
CRON-APT ACTION: 0-update
CRON-APT LINE: /usr/bin/apt-get -o quiet=1 -o Dir::Etc::SourceList=/etc/apt/security.sources.list update -o quiet=2
CRON-APT ACTION: 3-download
CRON-APT LINE: /usr/bin/apt-get -o quiet=1 -o Dir::Etc::SourceList=/etc/apt/security.sources.list autoclean -y
Reading package lists...
Building dependency tree...
Reading state information...
CRON-APT LINE: /usr/bin/apt-get -o quiet=1 -o Dir::Etc::SourceList=/etc/apt/security.sources.list dist-upgrade -y -o APT::Get::Show-Upgraded=true
Reading package lists...
Building dependency tree...
Reading state information...
Calculating upgrade...
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

Le programme utilise une tache cron pour se lancer automatiquement (par défaut , 4h00 du matin).
Pour spécifier le créneau horaire modifier le fichier /etc/cron.d/cron-apt.

Serveur de messagerie

Installation sécurisée d’un serveur de mail avec Postfix, Dovecot et Rainloop
Configure SPF and DKIM With Postfix on Debian 8

Serveur de messagerie

Prérequis

  • Domaine : xoyize.xyz
  • IPv4 du serveur : x.x.x.x
  • IPv6 du serveur : xxxx:xxxx:xx:xxxx::1
  • Courrier entrant : imap.xoyize.xyz sur port 993 (imaps)
  • Courrier sortant : smtp.xoyize.xyz sur port 587 (submission)
  • Compte courrier : yann@xoyize.xyz
  • Certificats : Let’s Encrypt
  • Serveur Debian Stretch + Nginx + PHP7 + MariaDb + accès SSH
  • DNS de base configuré (OVH)

Vérifier que les enregistrements MX de votre configuration DNS du domaine xoyize.xyz pointent vers votre serveur:

dig +short MX xoyize.xyz
	10 xoyize.xyz.

Les certificats letsencrypt

/etc/ssl/private/xoyize.xyz-fullchain.pem
/etc/ssl/private/xoyize.xyz-key.pem
/etc/ssl/private/xoyize.xyz-chain.pem
/etc/ssl/private/xoyize.xyz-ca.pem

Toutes les opérations se font en mode su

sudo -s

Postfix

Postfix

On commence par installer Postfix avec le support de mysql. Les domaines, comptes utilisateurs et alias seront ainsi gérés directement au sein d’une base de données, que vous pourrez administrer grâce à vos outils habituels, comme phpMyAdmin par exemple.

apt install postfix postfix-mysql -y

Postfix, compléter les options comme ceci :

Configuration type du serveur de messagerie : Site Internet
Nom de courrier : xoyize.xyz

Générer les paramètres DH :

openssl dhparam -out /etc/postfix/dh_2048.pem -2 -rand /var/run/egd-pool 2048 # on peur coder 2048 au lieu de 1024
openssl dhparam -out /etc/postfix/dh_512.pem -2 -rand /var/run/egd-pool 512

Création d’une base postfix et d’un utilisateur postfix ayant tous les privilèges sur la base :

mysql -u root -p

La requête :

CREATE DATABASE postfix;
CREATE USER 'postfix'@'localhost' IDENTIFIED BY 'iq9awn3wEuUPxsi6qrdU';
GRANT ALL PRIVILEGES ON `postfix`.* TO 'postfix'@'localhost';
FLUSH PRIVILEGES;
QUIT

PostfixAdmin

Télécharger la dernière version sur le dossier /var/www

cd /var/www
wget 'http://sourceforge.net/projects/postfixadmin/files/postfixadmin/postfixadmin-3.1/postfixadmin-3.1.tar.gz/download' -O pfa.tar.gz
tar -zxvf pfa.tar.gz
mv postfixadmin-3.1 pfa
rm pfa.tar.gz
chown -R www-data. pfa
cd pfa

Il faut également télécharger php imap

apt install php7.0-imap -y

Vous n’avez plus qu’à créer le fichier config.local.php dans le répertoire de PostfixAdmin /var/www/pfa :

nano /var/www/pfa/config.local.php

<?php
$CONF['configured'] = true;
$CONF['database_type'] = 'mysqli';
$CONF['database_host'] = 'localhost';
$CONF['database_user'] = 'postfix';
$CONF['database_password'] = 'iq9awn3wEuUPxsi6qrdU';
$CONF['database_name'] = 'postfix';
$CONF['admin_email'] = 'admin@xoyize.xyz';
$CONF['domain_path'] = 'YES';
$CONF['domain_in_mailbox'] = 'NO';
$CONF['fetchmail'] = 'NO';
$CONF['encrypt'] = 'md5crypt';
?>

Les droits

chown www-data.www-data /var/www/pfa/config.local.php

Pour éviter l’erreur lors de l’accès à setup.php : ERROR: the templates_c directory doesn’t exist or isn’t writeable for the webserver :

mkdir -p /var/www/pfa/templates_c
chown -R www-data: /var/www/pfa/templates_c/

Rendez-vous sur le setup.php de PostfixAdmin depuis votre navigateur https://xoyize.xyz/pfa/setup.php
Une vérification est effectué et si tout est OK ,il faut créer un “Setup password” puis générer un hash bouton “generate password hash”
Editer le fichier le fichier config.local.php pour y ajouter le hash du “Setup password” :

$CONF['setup_password'] = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';

Ajouter un administrateur (Create superadmin account) nommé postfixadmin@xoyize.xyz
Le message suivant “You can now login to PostfixAdmin using the account you just created.” nous indique que lèon peut se connecter

Ouvrir l’interface d’administration de PostfixAdmin https://xoyize.xyz/pfa/login.php avec postfixadmin@xoyize.xyz , vous devez ajouter un nouveau domaine puis un nouveau compte courrier.

  • Domaine : xoyize.xyz
  • Compte courriel : yan@xoyize.xyz

Configuration de Postfix

Maintenant nous allons devoir configurer Postfix pour qu’il prenne en charge correctement les connexions SMTP et l’envoie des messages sur le réseau pour chaque utilisateur créé via PostfixAdmin. Faites une sauvegarde du fichier de conf de Postfix /etc/postfix/main.cf :

cp /etc/postfix/main.cf /etc/postfix/main.cf.bak
nano /etc/postfix/main.cf
# Règles sur les adresses de destination
# permit_sasl_authenticated : Accepter la connexion lorsque le client est authentifié
# reject_non_fqdn_recipient : Refuser les adresses de destinations invalides (non FQDN)
smtpd_recipient_restrictions =
     permit_mynetworks,
     permit_sasl_authenticated,
     reject_non_fqdn_recipient,
     reject_unauth_destination,
     reject_unknown_recipient_domain,
     reject_rbl_client zen.spamhaus.org

# Règles sur l'échange HELO qui survient avant la connexion
# reject_invalid_helo_hostname : Refuser les échanges HELO invalides
# reject_non_fqdn_helo_hostname : Refuser les noms d'hôte invalides (non FQDN)
# reject_unknown_helo_hostname : Refuser les noms d'hôte qui n'ont pas de champ DNS A ou MX dans leurs DNS.
smtpd_helo_restrictions =
     permit_mynetworks,
     permit_sasl_authenticated,
     reject_invalid_helo_hostname,  

     reject_non_fqdn_helo_hostname,
     # reject_unknown_helo_hostname   

# Règles de connexion des clients
# permit_sasl_authenticated : Accepter la connexion lorsque le client est authentifié
# reject_plaintext_session : Refuser les connexions non sécurisées
# reject_unauth_pipelining : Refuser les défauts lors de la connexion
smtpd_client_restrictions =
     permit_mynetworks,
     permit_inet_interfaces,
     permit_sasl_authenticated,   
     # reject_plaintext_session,    
     # reject_unauth_pipelining     

# Règles sur les expéditeurs
# reject_non_fqdn_sender : Refuser les expéditeurs invalides (non FQDN)
# reject_unknown_sender_domain : Refuser les expéditeurs qui n'ont pas de champ DNS A ou MX dans leurs DNS.
# reject_sender_login_mismatch : Refuser les expéditeurs locaux non authentifiés
smtpd_sender_restrictions =
     reject_non_fqdn_sender,      

     reject_unknown_sender_domain,
     reject_sender_login_mismatch

Ensuite nous allons définir les paramètres de chiffrement via TLS :

# Smtp ( OUTGOING / Client )
smtp_tls_loglevel            = 1
smtp_tls_security_level      = may
smtp_tls_CAfile              = /etc/ssl/private/xoyize.xyz-ca.pem
smtp_tls_protocols           = !SSLv3
smtp_tls_mandatory_protocols = !SSLv3
smtp_tls_mandatory_ciphers   = high
smtp_tls_exclude_ciphers     = aNULL, eNULL, EXPORT, DES, 3DES, RC2, RC4, MD5, PSK, SRP, DSS, AECDH, ADH
smtp_tls_note_starttls_offer = yes

# ---------------------------------------------------------------------------------------------------

# Smtpd ( INCOMING / Server )
smtpd_tls_loglevel            = 1
smtpd_tls_auth_only           = yes
smtpd_tls_security_level      = may
smtpd_tls_received_header     = yes
smtpd_tls_protocols           = !SSLv3
smtpd_tls_mandatory_protocols = !SSLv3
smtpd_tls_mandatory_ciphers   = medium

# Infos (voir : postconf -d)
# Medium cipherlist = aNULL:-aNULL:ALL:!EXPORT:!LOW:+RC4:@STRENGTH
# High cipherlist   = aNULL:-aNULL:ALL:!EXPORT:!LOW:!MEDIUM:+RC4:@STRENGTH

# smtpd_tls_exclude_ciphers   = NE PAS modifier cette directive pour des raisons de compatibilité
#                               avec les autres serveurs de mail afin d'éviter une erreur du type
#                               "no shared cipher" ou "no cipher overlap" puis un fallback en
#                               plain/text...
# smtpd_tls_cipherlist        = Ne pas modifier non plus !

smtpd_tls_CAfile              = $smtp_tls_CAfile
smtpd_tls_cert_file           = /etc/ssl/private/xoyize.xyz-chain.pem
smtpd_tls_key_file            = /etc/ssl/private/xoyize.xyz-key.pem
smtpd_tls_dh1024_param_file   = $config_directory/dh2048.pem
smtpd_tls_dh512_param_file    = $config_directory/dh512.pem

tls_preempt_cipherlist = yes
tls_random_source      = dev:/dev/urandom

smtp_tls_session_cache_database  = btree:${data_directory}/smtp_scache
smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_scache
lmtp_tls_session_cache_database  = btree:${data_directory}/lmtp_scache

Ensuite nous allons définir les paramètres de connexion via SASL :

# Paramètres de connexion SASL
# C'est ici que l'on déclare Dovecot comme une passerelle pour authentifier les utilisateurs.
# Postfix peut s'appuyer sur Dovecot pour identifier les connexions SMTP.
smtpd_sasl_auth_enable          = yes
smtpd_sasl_type                 = dovecot
smtpd_sasl_path                 = private/auth
smtpd_sasl_security_options     = noanonymous
smtpd_sasl_tls_security_options = $smtpd_sasl_security_options
smtpd_sasl_local_domain         = $mydomain
smtpd_sasl_authenticated_header = yes

broken_sasl_auth_clients = yes

Maintenant on va s’occuper de la gestion et du stockage des emails. Dans la suite de ce tutoriel nous allons créer un utilisateur nommé vmail avec UID/GID de 5000, avec un HOME par défaut pointant sur /var/mail. Postfix doit le savoir donc on lui indique avec les 4 paramètres suivants :

virtual_uid_maps        = static:5000
virtual_gid_maps        = static:5000
virtual_minimum_uid     = 5000
virtual_mailbox_base    = /var/mail

Les 4 règles suivantes permettent à Postfix de savoir comment se connecter et lire la base de donnée afin de récupérer des informations sur les différents domaines, adresses virtuelles et alias. Nous allons détailler le contenu de ces 4 fichiers juste après.

virtual_mailbox_domains = mysql:/etc/postfix/mysql-virtual-mailbox-domains.cf
virtual_mailbox_maps    = mysql:/etc/postfix/mysql-virtual-mailbox-maps.cf
virtual_alias_maps      = mysql:/etc/postfix/mysql-virtual-alias-maps.cf

smtpd_sender_login_maps  = mysql:/etc/postfix/mysql-sender-login-maps.cf

Le paramètre virtual_transport est très très important, il permet à Postfix de savoir où envoyer les emails reçus. Dans notre cas, on utilise le protocole LMTP pour les acheminer jusqu’à Dovecot :

virtual_transport = lmtp:unix:private/dovecot-lmtp

Il ne reste plus qu’à definir les paramètres généraux. N’oubliez pas de modifier la valeur de myhostname et myorigin en indiquant votre FQDN.

smtpd_banner         = $myhostname ESMTP $mail_name (Debian/GNU)
biff                 = no
append_dot_mydomain  = no
readme_directory     = no
delay_warning_time   = 4h
mailbox_command      = procmail -a "$EXTENSION"
recipient_delimiter  = +
disable_vrfy_command = yes
message_size_limit   = 502400000
mailbox_size_limit   = 1024000000

inet_interfaces = all
inet_protocols = ipv4

myhostname    = xoyize.xyz
myorigin      = xoyize.xyz
mydestination = localhost localhost.$mydomain
mynetworks    = 127.0.0.0/8 [::ffff:127.0.0.0]/104 [::1]/128
relayhost     =

alias_maps     = hash:/etc/aliases
alias_database = hash:/etc/aliases

C’est terminé pour le fichier de configuration principale, je vous l’accorde il y a pas mal de paramètres à prendre en compte mais dans le cas d’un serveur SMTP c’est pas étonnant.
Vous pouvez aller voir la documentation de Postfix si vous voulez avoir plus d’informations sur sa configuration. http://www.postfix.org/postconf.5.html
Fichier de configuration complet main.cf : https://gist.github.com/hardware/b26918353c6325c09310

Configuration de Postfix pour MySQL/MariaDb

Créer les 4 fichiers de configuration qui vont permettre à Postfix d’interagir avec MySQL :

nano /etc/postfix/mysql-virtual-mailbox-domains.cf
hosts = 127.0.0.1
user = postfix
password = iq9awn3wEuUPxsi6qrdU
dbname = postfix

query = SELECT domain FROM domain WHERE domain='%s' and backupmx = 0 and active = 1
nano /etc/postfix/mysql-virtual-mailbox-maps.cf
hosts = 127.0.0.1
user = postfix
password = iq9awn3wEuUPxsi6qrdU
dbname = postfix

query = SELECT maildir FROM mailbox WHERE username='%s' AND active = 1
nano /etc/postfix/mysql-virtual-alias-maps.cf
hosts = 127.0.0.1
user = postfix
password = iq9awn3wEuUPxsi6qrdU
dbname = postfix

query = SELECT goto FROM alias WHERE address='%s' AND active = 1
nano /etc/postfix/mysql-sender-login-maps.cf
hosts = 127.0.0.1
user = postfix
password = iq9awn3wEuUPxsi6qrdU
dbname = postfix

query = SELECT username FROM mailbox WHERE username='%s' AND active = 1

Si vous voulez activer le port 587 pour vous connecter de manière sécurisé par SMTPS avec n’importe quel client mail, il faut décommenter/modifier les lignes suivantes dans le fichier /etc/postfix/master.cf :

submission inet n       -       -       -       -       smtpd
  -o syslog_name=postfix/submission
  -o smtpd_tls_dh1024_param_file=/etc/postfix/dh_2048.pem
  -o smtpd_tls_security_level=encrypt
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_client_restrictions=permit_sasl_authenticated,reject

Et n’oubliez pas de décommentez cette ligne aussi si ce n’est pas déjà fait :

smtp  inet  n       -       -       -       -       smtpd

Fichier de configuration complet master.cf : https://gist.github.com/hardware/dcc120df9329da7f40ec

Dovecot

Dovecot

Liens utiles :
http://fr.wikipedia.org/wiki/Dovecot
http://wiki2.dovecot.org/

Dovecot est un serveur IMAP et POP3 pour les systèmes d’exploitation Unix et dérivés, conçu avec comme premier but la sécurité. Dovecot est distribué en double licence MIT et GPL version 2.

Installation des paquets :

apt install dovecot-core dovecot-imapd dovecot-lmtpd dovecot-mysql -y

Configuration de dovecot

Ajoutez la liste des protocoles activés après l’instruction “!include_try” dans le fichier /etc/dovecot/dovecot.conf. Dans notre cas, nous allons activer IMAP pour la récupération des emails via le port 993 et LMTP pour l’acheminement des emails entre Postfix et Dovecot :

nano /etc/dovecot/dovecot.conf
!include_try /usr/share/dovecot/protocols.d/*.protocol
protocols = imap lmtp
listen = *

# Assurez-vous que cette ligne est bien décommentée :
!include conf.d/*.conf

Fichier de configuration complet dovecot.conf : https://gist.github.com/hardware/ce55b0d241e229d5176a

On indique le chemin du conteneur local qui contiendra tous nos emails. Editez le fichier 10-mail.conf :

nano /etc/dovecot/conf.d/10-mail.conf
# Le contenur local est organisé de cette manière :
# /var/mail/vhosts/xoyize.xyz/utilisateur
mail_location = maildir:/var/mail/vhosts/%d/%n/mail
maildir_stat_dirs=yes

namespace inbox {
    inbox = yes
}

mail_uid = 5000
mail_gid = 5000

first_valid_uid = 5000
last_valid_uid = 5000

mail_privileged_group = vmail

Fichier de configuration complet 10-mail.conf : https://gist.github.com/hardware/0fd157d8e83e09b50cb9

Les emails seront stockés dans le répertoire /var/mail. On doit donc créer un répertoire correspondant à notre domaine (celui qui est présent dans la table “domain”).

mkdir -p /var/mail/vhosts/xoyize.xyz

Maintenant on ajoute un nouvel utilisateur et un nouveau groupe nommé vmail avec un UID/GID de 5000 :

groupadd -g 5000 vmail
useradd -g vmail -u 5000 vmail -d /var/mail
chown -R vmail:vmail /var/mail

Editer le fichier 10-auth.conf et modifier les lignes suivantes :

nano /etc/dovecot/conf.d/10-auth.conf
disable_plaintext_auth = yes
auth_mechanisms = plain login
#!include auth-system.conf.ext # Commenter cette ligne
!include auth-sql.conf.ext     # décommenter cette ligne

Fichier de configuration complet 10-auth.conf : https://gist.github.com/hardware/3a70923d37e6ad7c1859

Maintenant on va définir deux méthodes qui vont permettrent à Dovecot de savoir comment obtenir les utilisateurs et les mots de passe correspondants lors de la connexion. Editez le fichier auth-sql.conf.ext :

nano /etc/dovecot/conf.d/auth-sql.conf.ext
# Le mot de passe est obtenu à partir de la base de donnée
passdb {
  driver = sql
  args = /etc/dovecot/dovecot-sql.conf.ext
}

# Par contre le nom d'utilisateur est obtenu de manière statique à partir du conteneur local
# %d = domaine.tld
# %n = utilisateur
userdb {
  driver = static
  args = uid=vmail gid=vmail home=/var/mail/vhosts/%d/%n
}

Ensuite editez le fichier dovecot-sql.conf.ext et modifiez les paramètres suivants :

nano/etc/dovecot/dovecot-sql.conf.ext
# Paramètres de connexion
driver = mysql
connect = host=127.0.0.1 dbname=postfix user=postfix password=iq9awn3wEuUPxsi6qrdU

# Permet de définir l'algorithme de hachage.
# Pour plus d'information: http://wiki2.dovecot.org/Authentication/PasswordSchemes
# /!\ ATTENTION : ne pas oublier de modifier le paramètre "$CONF['encrypt'] = 'md5crypt';" de PostfixAdmin
default_pass_scheme = MD5-CRYPT

# Requête de récupération du mot de passe du compte utilisateur
password_query = SELECT password FROM mailbox WHERE username = '%u'

Modifiez les permissions sur le répertoire /etc/dovecot :

chown -R vmail:dovecot /etc/dovecot
chmod -R o-rwx /etc/dovecot

Editer le fichier 10-master.conf avec le contenu suivant :

nano /etc/dovecot/conf.d/10-master.conf
service imap-login {

  inet_listener imap {
    port = 143
  }

  inet_listener imaps {
    port = 993
    ssl = yes
  }

  service_count = 0

}

service imap {

}

service lmtp {

  # On autorise Postfix à transférer les emails dans le spooler de Dovecot via LMTP
  unix_listener /var/spool/postfix/private/dovecot-lmtp {
      mode = 0600
      user = postfix
      group = postfix
  }

}

service auth {

  # On autorise Postfix à se connecter à Dovecot via LMTP
  unix_listener /var/spool/postfix/private/auth {
      mode = 0666
      user = postfix
      group = postfix
  }

  # On indique à Dovecot les permissions du conteneur local
  unix_listener auth-userdb {
      mode = 0600
      user = vmail
      group = vmail
  }

  user = dovecot

}

service auth-worker {

  user = vmail

}

Fichier de configuration complet dovecot-sql.conf.ext : https://gist.github.com/hardware/cdc1bae0a7e306501d15

Enfin, editez le fichier 10-ssl.conf et modifiez les paramètres suivants :

nano /etc/dovecot/conf.d/10-ssl.conf
ssl = required
ssl_cert = </etc/ssl/private/xoyize.xyz-chain.pem
ssl_key = </etc/ssl/private/xoyize.xyz-key.pem
ssl_protocols = !SSLv2 !SSLv3
#ssl_protocols = !SSLv3
ssl_cipher_list = ALL:!aNULL:!eNULL:!LOW:!MEDIUM:!EXP:!RC2:!RC4:!DES:!3DES:!MD5:!PSK:!SRP:!DSS:!AECDH:!ADH:@STRENGTH
ssl_prefer_server_ciphers = yes # Dovecot > 2.2.x
ssl_dh_parameters_length = 4096 # Dovecot > 2.2.x

Fichier de configuration complet 10-ssl.conf : https://gist.github.com/hardware/91ed5e01929b8b414ae0

Redémarrage des services et vérification des ports

On redémarre Postfix et Dovecot :

systemctl restart postfix dovecot

Puis on vérifie que les ports 25 (SMTP), 587 (SMTPS) et 993 (IMAPS) sont bien en écoute sur 0.0.0.0. N’oubliez pas de les ouvrir au niveau de votre Firewall :

netstat -ptna
Proto Recv-Q Send-Q Adresse locale          Adresse distante        Etat        PID/Program name    
tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN      6116/master         
tcp        0      0 0.0.0.0:993             0.0.0.0:*               LISTEN      6009/dovecot        
tcp        0      0 0.0.0.0:587             0.0.0.0:*               LISTEN      6116/master         
tcp        0      0 0.0.0.0:143             0.0.0.0:*               LISTEN      6009/dovecot        

Vous pouvez tester le serveur Postfix localement à partir du terminal en utilisant une connexion directe avec netcat, telnet ou similaire. Les commandes suivantes doivent être exécutées dans l’ordre correct pour que le serveur ferme la connexion.

nc xoyize.xyz 25
EHLO $hostname
250-xoyize.xyz
250-PIPELINING
250-SIZE 502400000
250-ETRN
250-STARTTLS
250-ENHANCEDSTATUSCODES
250-8BITMIME
250 DSN

Si vous voyez 250-STARTTLS, c’est que le serveur supporte bien l’authentification par STARTTLS.

Dkim,Spf et Dmarc

OpenDKIM

OpenDkim

DKIM est un standard permettant d’associer de manière forte une entité ou une organisation avec un domaine au sein d’un email. On se déclare donc complètement responsable de la transmission du message sur le réseau. DKIM fonctionne par cryptographie asymétrique, le MTA (Mail Transfer Agent, dans notre cas il s’agit de Postfix) se charge de signer numériquement tous les emails envoyés avec une clé privée contenue sur le serveur. Le destinataire peut alors vérifier l’intégrité du corps ainsi que les en-têtes du message grâce à la clé publique fournie par le domainkey, qui est un champ TXT contenu dans les fichiers de zone de vos DNS.

Liens utiles :
http://fr.wikipedia.org/wiki/DomainKeys_Identified_Mail
http://www.opendkim.org/docs.html

On commence par installer OpenDKIM :

apt-get install opendkim opendkim-tools

Editez le fichier de configuration opendkim.conf avec le contenu suivant :

nano /etc/opendkim.conf
AutoRestart             Yes
AutoRestartRate         10/1h
UMask                   002
Syslog                  Yes
SyslogSuccess           Yes
LogWhy                  Yes

OversignHeaders         From
AlwaysAddARHeader       Yes
Canonicalization        relaxed/simple

ExternalIgnoreList      refile:/etc/opendkim/TrustedHosts
InternalHosts           refile:/etc/opendkim/TrustedHosts
KeyTable                refile:/etc/opendkim/KeyTable
SigningTable            refile:/etc/opendkim/SigningTable

Mode                    sv
PidFile                 /var/run/opendkim/opendkim.pid
SignatureAlgorithm      rsa-sha256

UserID                  opendkim:opendkim

Socket                  local:/var/spool/postfix/opendkim/opendkim.sock

Pour que Postfix puisse communiquer avec OpenDKIM, on va utiliser un socket, il faut créer le répertoire /var/spool/postfix/opendkim

mkdir /var/spool/postfix/opendkim
chown opendkim: /var/spool/postfix/opendkim
usermod -aG opendkim postfix

Ensuite on doit indiquer à Postfix comment s’interfacer avec OpenDKIM. Pour cela, editer le fichier main.cf et ajouter les lignes suivantes à fin du fichier de configuration :

nano /etc/postfix/main.cf
milter_protocol = 6
milter_default_action = accept
smtpd_milters = unix:/var/spool/postfix/opendkim/opendkim.sock
non_smtpd_milters = unix:/var/spool/postfix/opendkim/opendkim.sock

Créér le répertoire suivant :

mkdir -p /etc/opendkim/keys

Ajoutez le fichier TrustedHosts avec le contenu suivant :

nano /etc/opendkim/TrustedHosts
127.0.0.1
localhost
::1
*.xoyize.xyz

N’oubliez pas de modifier xoyize.xyz par votre nom de domaine.

Ajoutez le fichier KeyTable avec le contenu suivant. Dans cet exemple, nous utiliserons un sélecteur nommé mail. Vous pouvez le nommer comme vous le souhaitez.

nano /etc/opendkim/KeyTable
mail._domainkey.xoyize.xyz xoyize.xyz:mail:/etc/opendkim/keys/xoyize.xyz/mail.private

Ajoutez le fichier SigningTable avec le contenu suivant :

nano /etc/opendkim/SigningTable
*@xoyize.xyz mail._domainkey.xoyize.xyz

Création de la clé publique et privée

Création du répertoire qui contiendra les clés :

cd /etc/opendkim/keys
mkdir xoyize.xyz && cd xoyize.xyz

Génération des clés de chiffrement :

# Paramètres : -s [sélecteur] -d [nom de domaine] -b [taille de la clé]
opendkim-genkey -s mail -d xoyize.xyz -b 4096

Certains registrars n’acceptent pas les clés > 1024 bits donc pensez à changer le paramètre au-dessus si besoin.

Modification des permissions de la clé privée :

chown opendkim:opendkim mail.private

Les permissions doivent être les suivantes (chmod 400) :

ls -lX /etc/opendkim/keys/xoyize.xyz/

-rw------- 1 opendkim opendkim 3243 févr. 14 21:05 mail.private
-rw------- 1 root     root      850 févr. 14 21:05 mail.txt

Modification des DNS : Ajout de la clé publique

Copiez le contenu du fichier mail.txt (la clé publique) :

cat mail.txt

Le format de l’enregistrement DKIM est comme ceci :

mail._domainkey IN TXT "v=DKIM1; k=rsa; p=VOTRE CLE PUBLIQUE"

La clé de 4096 bits :

cat mail.txt
mail._domainkey	IN	TXT	( "v=DKIM1; k=rsa; "
	  "p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5tSGc+j5pLEuWeR4NIhDRPhwHUZll1/N3ajHF1wSttUVp/igdcpZTKTD7ccFmsY0l+72Q+rlnoCGGdhdw0ImRoPVZwBfSxvC3alw/YLLCEwpy+J/tXx2WOPdHM95TVbt0S/wVWpPxmr3mAIPO24R4NEf0yQdvktnB26UTcLBEMtqAEtEDLqrea/XM5HQMngWXAARy379H6mo1Y"
	  "ee3wUqYZPX+g8ljZZMpIlvaE0pjtVIZ0kV8/kXz0fa1XHanc6rTsF7/XxCLYJRAK6fcfO8u/Ro65uWNM3x8+WN1nkf/ojh8VN/0A5oUrlQVWba4OEXxCkbZTU7V+4okyyhAHV2+/c0qRsKRNj2YuPl3DmJ8/me/UBHbIEeji7kcBuVkgv0cakHolMbKWESBuuw1F5MPThQ3qbUcCI9mY4OtTnElk40DVXMenKwQ1EnqJZlHtj6XOo0/na4"
	  "epqH+rtUOXhan6ewd8XQvJk630Qi1FHzWmO7i4pb8Uo0EDrAQmPvCNsR+AttrIdK7Ry3xgKAUdSyfT2GXmtP3hpr4l2w0Qv0sXAkVzz9xF0OsUjb3pztdAKz9t9pHiIj3C5p0HQZTAr7oVAzjiDu6gntfoMzTB6mY6PKF2TYOBagu0AZAwgwuWb24zrGPXRPS8U01TlY6UVzFJbB+97i0Nim5jQmyf/r38cCAwEAAQ==" )  ; ----- DKIM key mail for domaine.tld

Pour OVH il faut supprimer les guillements intermédiaires

mail._domainkey	IN	TXT	( "v=DKIM1; k=rsa; p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5tSGc+j5pLEuWeR4NIhDRPhwHUZll1/N3ajHF1wSttUVp/igdcpZTKTD7ccFmsY0l+72Q+rlnoCGGdhdw0ImRoPVZwBfSxvC3alw/YLLCEwpy+J/tXx2WOPdHM95TVbt0S/wVWpPxmr3mAIPO24R4NEf0yQdvktnB26UTcLBEMtqAEtEDLqrea/XM5HQMngWXAARy379H6mo1Yee3wUqYZPX+g8ljZZMpIlvaE0pjtVIZ0kV8/kXz0fa1XHanc6rTsF7/XxCLYJRAK6fcfO8u/Ro65uWNM3x8+WN1nkf/ojh8VN/0A5oUrlQVWba4OEXxCkbZTU7V+4okyyhAHV2+/c0qRsKRNj2YuPl3DmJ8/me/UBHbIEeji7kcBuVkgv0cakHolMbKWESBuuw1F5MPThQ3qbUcCI9mY4OtTnElk40DVXMenKwQ1EnqJZlHtj6XOo0/na4epqH+rtUOXhan6ewd8XQvJk630Qi1FHzWmO7i4pb8Uo0EDrAQmPvCNsR+AttrIdK7Ry3xgKAUdSyfT2GXmtP3hpr4l2w0Qv0sXAkVzz9xF0OsUjb3pztdAKz9t9pHiIj3C5p0HQZTAr7oVAzjiDu6gntfoMzTB6mY6PKF2TYOBagu0AZAwgwuWb24zrGPXRPS8U01TlY6UVzFJbB+97i0Nim5jQmyf/r38cCAwEAAQ==" )  ; ----- DKIM key mail for domaine.tld

On redémarre tous les services :

systemctl restart postfix dovecot opendkim

Les services démarrent automatiquement lors du boot (service enable lors de l’installation du paquet sur debian 9) :

Attendez quelques minutes la propagation des DNS. Vous pouvez vérifier que le champ domainkey est bien visible en exécutant la commande suivante à partir de votre pc :

host -t TXT mail._domainkey.xoyize.xyz

Si elle retourne ce message :

Host mail._domainkey.xoyize.xyz not found: (NXDOMAIN)

C’est que vos DNS ne se sont pas encore propagés sur les serveurs de votre FAI, patientez encore un peu.

SPF (Sender Policy Framework)

Sender Policy Framework (SPF) est une norme de vérification du nom de domaine de l’expéditeur d’un courrier électronique, normalisé dans la RFC 7208. L’adoption de cette norme est de nature à réduire le spam.(Wikipédia)

Ajoutez cette ligne dans le fichier de zone de votre nom de domaine :

@        IN      TXT     "v=spf1 a mx ip4:ADRESSE IP DE VOTRE SERVEUR ~all"
# OVH
600 IN TXT "v=spf1 a mx ip4:93.115.96.97 ip6:2a03:75c0:35:670d::1 ~all"

DMARC

Dmarc

DMARC (Domain-based Message Authentication, Reporting & Conformance) est une spécification technique assez récente (2011), qui est toujours en draft par l’IETF ( https://datatracker.ietf.org/doc/rfc7489/ ), les contributeurs initiaux sont un consortium de plusieurs géants d’internet comme AOL, Yahoo, Google, Microsoft, Paypal, Facebook…etc. Cette spécification permet de réduire l’usage abusif des e-mails, tels que le spam, le phishing en ajoutant une couche supplémentaire dans le processus d’authentification des mails.

apt install opendmarc

Editer le fichier de configuration opendmarc.conf avec le contenu suivant :

nano /etc/opendmarc.conf
AutoRestart             Yes
AutoRestartRate         10/1h
UMask                   0002
Syslog                  true

AuthservID              "xoyize.xyz"
TrustedAuthservIDs      "xoyize.xyz"
IgnoreHosts             /etc/opendkim/TrustedHosts
IgnoreMailFrom          "xoyize.xyz"
RejectFailures          false

UserID                  opendmarc:opendmarc
PidFile                 /var/run/opendmarc/opendmarc.pid
Socket                  local:/var/spool/postfix/opendmarc/opendmarc.sock

Pour que Postfix puisse communiquer avec Opendmarc, on va utiliser un socket, il faut créer le répertoire /var/spool/postfix/opendmarc

mkdir /var/spool/postfix/opendmarc
chown opendmarc: /var/spool/postfix/opendmarc
usermod -aG opendmarc postfix

Ensuite dans le fichier /etc/postfix/main.cf, editer cette ligne :

smtpd_milters = unix:/var/spool/postfix/opendkim/opendkim.sock, unix:/var/spool/postfix/opendmarc/opendmarc.sock

Puis on redémarre les services :

systemctl restart opendmarc postfix

Pour tester le bon fonctionnement du serveur de mail, utilisez le site http://www.mail-tester.com/

ATTENTION, le paramètre Socket n’est pas pris en compte , il faut paraméter smtpd_milters avec unix:/var/run/opendmarc/opendmarc.sock
Il faut activer le service systemctl enable opendmarc

SpamAssassin (Anti SPAM)

SpamAssassin

SpamAssassin est un logiciel libre permettant de filtrer les emails afin d’éradiquer au maximum le SPAM. Il fait passer un certain nombre de tests au message et en fonction du résultat de ces tests, il attribue un score qui permettra de savoir si il s’agit d’un email indésirable ou non.

Liens utiles :
http://spamassassin.apache.org/
http://fr.wikipedia.org/wiki/SpamAssassin

Installer SpamAssassin :

apt install spamassassin spamc

Ensuite on modifie le fichier de configuration de Postfix /etc/postfix/master.cf :

smtp      inet  n       -       -       -       -       smtpd
   -o content_filter=spamassassin

Ajoutez aussi ces deux lignes à la fin du fichier :

spamassassin unix -     n       n       -       -       pipe
  user=debian-spamd argv=/usr/bin/spamc -f -e /usr/sbin/sendmail -oi -f ${sender} ${recipient}

Ok maintenant on relance postfix avec la commande suivante :

systemctl restart postfix

Dans le fichier /etc/spamassassin/local.cf, décommenter la ligne suivante :

rewrite_header Subject *****SPAM*****

Les mails considérés comme du SPAM auront un sujet préfixé avec SPAM. Ils pourront ainsi être traités comme vous le souhaitez en paramétrant un filtre dans votre client mail.

Ajouter aussi à la fin du fichier local.cf :

report_safe 0
whitelist_auth *@xoyize.xyz

add_header all Report _REPORT_
add_header spam Flag _YESNOCAPS_
add_header all Status _YESNO_, score=_SCORE_ required=_REQD_ tests=_TESTS_ autolearn=_AUTOLEARN_ version=_VERSION_
add_header all Level _STARS(*)_
add_header all Checker-Version SpamAssassin _VERSION_ (_SUBVERSION_) on _HOSTNAME_

Pour avoir un rapport détaillé dans les headers de tous les mails, comme ceci :

X-Spam-Report:
	* -5.0 RCVD_IN_DNSWL_HI RBL: Sender listed at http://www.dnswl.org/, high
	*      trust
	*      [66.45.63.27 listed in list.dnswl.org]
	* -3.0 RCVD_IN_RP_CERTIFIED RBL: Sender in ReturnPath Certified - Contact
	*      cert-sa@returnpath.net
	*      [Return Path SenderScore Certified {formerly]
	[Bonded Sender} - <http://www.senderscorecertified.com>]
	* -2.0 RCVD_IN_RP_SAFE RBL: Sender in ReturnPath Safe - Contact
	*      safe-sa@returnpath.net
	*      [Return Path SenderScore Safe List (formerly]
	[Habeas Safelist) - <http://www.senderscorecertified.com>]
X-Spam-Status: No, score=-10.0 required=5.0 tests=RCVD_IN_DNSWL_HI,
	RCVD_IN_RP_CERTIFIED,RCVD_IN_RP_SAFE autolearn=ham
	version=3.3.2
X-Spam-Level:
X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on hostname.domain.tld

L’exemple ci-dessus montre un très bon élève (returnpath.net) mais ça sera pas toujours le cas avec les mails que vous recevrez

Dans le fichier /etc/default/spamassassin, modifier ces deux lignes :

# If you're using systemd (default for jessie), the ENABLED setting is
# not used. Instead, enable spamd by issuing:
# systemctl enable spamassassin.service
# Change to "1" to enable spamd on systems using sysvinit:
ENABLED=0
# Cronjob
# Set to anything but 0 to enable the cron job to automatically update
# spamassassin's rules on a nightly basis
CRON=0

On active le service lors du boot puis on le démarre :

systemctl enable spamassassin.service
systemctl start spamassassin.service

Pour finir, ajouter au cron ces 3 lignes avec contab :

crontab -e
# Mise à jour des règles de spamassassin
20 02 * * * /usr/bin/sa-update

# Auto-apprentissage de spam assassin avec utilisateur yan
30 02 * * * /usr/bin/sa-learn --ham /var/mail/vhosts/xoyize.xyz/yan/mail/cur/*
40 02 * * * /usr/bin/sa-learn --spam /var/mail/vhosts/xoyize.xyz/yan/mail/.Spam/cur/*

Spamassassin est très intelligent, il peut apprendre tout seul au fur et à mesure que vous recevez des mails, lorsque vous ajoutez manuellement un mail dans le dossier spam (ce qui veut dire qu’il ne l’avait pas détecté en tant que tel), sa-learn –spam permet de mettre à jour le filtrage bayésien (http://fr.wikipedia.org/wiki/Filtrage_bay%C3%A9sien_du_spam) en analysant les mails contenus dans le dossier spam, donc Spamassassin s’améliore un peu chaque jour en fonction de vous, si c’est pas cool ça

Le contraire est aussi possible avec la commande sa-learn –ham, si Spamassassin considère un mail en tant que spam alors que ce n’est pas le cas (faux positif), vous pouvez lui indiquer en remettant le mail dans le dossier principal de réception (INBOX).

Correction erreur spamd: failed to create readable default_prefs: /var/lib/spamassassin/.spamassassin/user_prefs
Ajout utilisateur debian-spamd à la ligne OPTIONS du fichier /etc/default/spamassassin

OPTIONS="--create-prefs --max-children 5 --helper-home-dir -u debian-spamd"

Modifier les droits sur le dossier .spamassassin

chown debian-spamd -R /var/lib/spamassassin/.spamassassin

Redémarrer spamassassin

systemctl restart spamassassin

Dovecot Sieve (Filtrer les mails côté serveur)

Vous connaissez très certainement les filtres côté clients, tout bon client mail possède un système de filtre permettant de trier automatiquement les mails en fonction de différents critères que vous pouvez définir. Sieve c’est exactement la même chose mais côté serveur, il possède un langage de script pour définir soit même l’ensemble des règles.

Pour installer sieve, exécuter la commande suivante :

apt install dovecot-sieve dovecot-managesieved

Éditer le fichier principal de configuration de Dovecot et ajouter sieve dans la liste des protocoles :

nano /etc/dovecot/dovecot.conf
protocols = imap lmtp sieve

Ensuite dans le fichier /etc/dovecot/conf.d/20-lmtp.conf, ajouter le contenu suivant :

protocol lmtp { postmaster_address = postmaster@xoyize.xyz mail_plugins = $mail_plugins sieve }

Dans le fichier /etc/dovecot/conf.d/90-sieve.conf, modifier la configuration du plugin :

plugin {

sieve = /var/mail/vhosts/%d/%n/.dovecot.sieve
sieve_default = /var/mail/sieve/default.sieve
sieve_dir = /var/mail/vhosts/%d/%n/sieve
sieve_global_dir = /var/mail/sieve

}

Puis :

mkdir /var/mail/sieve/
touch /var/mail/sieve/default.sieve && chown -R vmail:vmail /var/mail/sieve

Par défaut, vous pouvez mettre toutes les règles dans le fichier default.sieve, elles s’appliqueront à toutes les adresses, les règles spécifiques à une adresse doivent être mises dans le fichier /var/mail/vhosts/xoyize.xyz/adresse/.dovecot.sieve. Attention si ce fichier existe, le fichier par défaut (default.sieve) ne sera pas lu pour l’utilisateur courant.

Pour ce tutoriel, on va ajouter dans /var/mail/sieve/default.sieve une règle basique mais très utile :

require ["fileinto"];

if header :contains "Subject" "*****SPAM*****" {

fileinto "Spam";

}

Je pense que c’est assez explicite pour comprendre le but de cette règle
Et pour finir compiler les règles avec la commande sievec :

sievec /var/mail/sieve/default.sieve

et on redémarre Dovecot :

systemctl restart dovecot

Vous pouvez tester la règle en envoyant un email depuis un autre fournisseur de mail avec le contenu suivant :

XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X

Si tout fonctionne bien vous devriez recevoir le mail automatiquement dans le dossier Spam (Junk). N’hésitez pas à aller voir la documentation, pour créer d’autres règles. L’avantage de ce système c’est que les règles sont côté serveur donc elles s’appliquent à tous vos clients mail, pas besoin de les refaire lorsque vous changez de client.

Liens utiles :
http://wiki2.dovecot.org/Pigeonhole/Sieve
http://wiki2.dovecot.org/Pigeonhole/Sieve/Examples

Rainloop intègre le support de Sieve directement depuis le webmail, nous allons avoir comment activer cette fonctionnalité. Connectez-vous avec votre compte administrateur à rainloop puis aller dans Domains > cliquez sur votre domaine puis sur Sieve configuration et enfin configurer comme sur l’image suivante :

Rainloop sieve

Cliquer sur le bouton “Test” pour tester la connexion avec SieveManager, si c’est bon, il passe au vert. Maintenant il faut se connecter à un compte utilisateur, aller dans les paramètres > Filtres. Vous pouvez dès à présent configurer vos filtres depuis cette interface.

Il existe aussi un plugin similaire pour Thunderbird ici : https://addons.mozilla.org/fr/thunderbird/addon/sieve/

ClamAV (Antivirus)

Clamav

ClamAV est un antivirus destiné aux systèmes UNIX principalement. Il est capable de détecter en temps réel des logiciels malveillants et des virus grâce à une base de détection de plus de 3 500 000 signatures. ClamAV est généralement utilisé avec Postfix pour filtrer les emails comportant des virus, malwares…etc

Liens utiles :
http://www.clamav.net/index.html
https://github.com/vrtadmin/clamav-faq/raw/master/manual/clamdoc.pdf
http://fr.wikipedia.org/wiki/ClamAV
https://lelutin.ca/posts/installing_postfix_-_clamav_-_spamassassin_-_dovecot_-_postfixadmin_on_debian_squeeze/

Installer le paquet clamav-milter depuis les dépôts officiels de Debian :

apt install clamav-milter

4 autres paquets seront installés en même temps :

  • clamav : C’est le paquet principal
  • clamav-base : C’est le paquet de base de ClamAV, contient divers outils pour son fonctionnement
  • clamav-daemon : Permet de faire tourner ClamAV en tâche de fond
  • clamav-freshclam : Outil permettant de mettre à jour la base de signature des virus

Ensuite, il faut lui dire de laisser postfix avoir accès en écriture à sa socket.(assurer que vous avez les éléments suivants dans votre fichier /etc/clamav/clamav-milter.conf)

MilterSocketGroup postfix
MilterSocketMode 660

Postfix fonctionne dans un chroot par défaut, donc nous allons devoir reconfigurer le milter pour placer sa socket dans le répertoire chroot de postfix. Mais d’abord, nous devons créer un répertoire pour le socket UNIX et on définit clamav en tant que propriétaire :

mkdir /var/spool/postfix/clamav
chown clamav /var/spool/postfix/clamav

Nous voulons également modifier les mesures prises lorsqu’un courriel infecté est détecté pour le rejeter immédiatement. Pour nous assurer que notre configuration reste stable grâce aux mises à jour, nous allons le faire à la manière debian:

dpkg-reconfigure clamav-milter

Repondez aux questions avec les réponses ci-dessous :

Faut-il gérer le fichier de configuration automatiquement ?	Oui
Identifiant qui exécutera clamav-milter :			clamav
Groupes de clamav-milter (séparés par des espaces) : 		laisser le champ vide
Interface de communication avec Sendmail :			/var/spool/postfix/clamav/clamav-milter.ctl
Groupe propriétaire du fichier « socket » de clamav-milter :	clamav
Autorisations du fichier « socket » de clamav-milter :		666
Faut-il supprimer la « socket » résiduelle après un arrêt brutal ?	Oui
Délai d'expiration pour les données provenant de clamd :	120
Faut-il interdire à clamav-milter de créer des processus fils (« fork ») ?	No
Répertoire de l'environnement d'exécution sécurisé :		laisser le champ vide
Fichier PID :							/var/run/clamav/clamav-milter.pid
Chemin des répertoires temporaires :				/tmp
« Socket » de clamd à utiliser pour le traitement :		unix:/var/spool/postfix/clamav/clamav-milter.ctl
Hôtes à exclure de la vérification :				laisser le champ vide
Liste blanche d'adresses de courriel : 				laisser le champ vide
Action à réaliser pour un courriel « infecté » :		Rejeter
Action à réaliser en cas d'erreur :				Différer
Motif de rejet des courriels infectés :				Rejecting harmful e-mail: %v found.
Faut-il ajouter des en-têtes aux courriels vérifiés ?		Remplacer
Fichier de journal de clamav-milter : 				/var/log/clamav/clamav-milter.log
Faut-il désactiver le verrouillage du fichier de journal ? 	Non
Taille maximale (en Mo) du fichier de journal :			0
Faut-il ajouter des informations temporelles dans le fichier de journal pour chaque courriel ? Oui
Faut-il utiliser le système de journalisation syslog ?		Non
Type des messages syslog :					LOG_LOCAL6
Faut-il activer la journalisation bavarde ? 			Non
Niveau d'information à journaliser pour les messages infectés :	Désactivé
Niveau d'information à journaliser en l'absence d'alerte :	Désactivé
Taille maximale (en Mo) des fichiers à vérifier :		25
Voulez-vous que clamav-milter gère plusieurs destinataires ? 	Non
Souhaitez-vous activer la rotation des journaux ?		Oui

La reconfiguration ci-dessus aurait dû redémarrer automatiquement clamav-milter. Vérifier que la prise est en place. Normalement, le démon clam doit être activé dans la procédure de démarrage, mais il est possible que vous ayez besoin de le démarrer manuellement juste après l’installation.

 service clamav-daemon start

Ensuite, nous allons configurer Postfix pour qu’il utilise le milter pour inspecter les e-mails entrants. Rappelez-vous que le processus smtp est exécuté dans un chroot, donc le chemin doit avoir sa racine en haut du répertoire chroot

postconf -e 'smtpd_milters = unix:/clamav/clamav-milter.ctl'
postfix reload

Test du filtre en envoyant un virus
Pour tester cela, nous devrons envoyer un fichier malveillant au serveur SMTP dans l’espoir qu’il le bloque. Pour cela, vous pouvez installer le paquet clamav-testfiles et swaks sur votre ordinateur; il installera des fichiers d’exemple de virus sous /usr/share/clamav-testfiles.

apt install clamav-testfiles swaks

Envoyons-en une comme pièce jointe à un courriel:
swaks --to=yannick@xoyize.xyz --server=vps26381 --attach - --suppress-data < /usr/share/clamav-testfiles/clam.exe

Par défaut, freshclam récupère les dernières mises à jour depuis le serveur principal database.clamav.net, on peut spécifier d’autres serveurs, plus proches, par exemple : db.fr.clamav.net

Dans le fichier /etc/clamav/freshclam.conf, ajouter la ligne suivante au-dessus des autres serveurs “DatabaseMirror” :

DatabaseMirror db.fr.clamav.net

Sous Debian 7, ajoutez une nouvelle tâche CRON pour mettre à jour la base de signature automatiquement toutes les heures.

crontab -e

15 * * * * /usr/bin/freshclam –quiet

La mise à jour est effectuée automatiquement sous Debian 8 Jessie, la tâche CRON n’est plus nécessaire.

On redémarre le daemon pour prendre en compte les modifications :

service clamav-daemon restart

Il ne reste plus qu’à dire à Postfix où se trouve le socket UNIX de clamav dans le fichier /etc/postfix/main.cf :

smtpd_milters = unix:/var/spool/postfix/opendkim/opendkim.sock, unix:/var/spool/postfix/opendmarc/opendmarc.sock, unix:/var/spool/postfix/clamav/clamav-milter.ctl

Recharger la configuration de Postfix :

systemctl reload postfix

Une fois que tous les paquets sont installés, il faut mettre à jour la base de signature avec freshclam :

systemctl stop clamav-freshclam
freshclam
ClamAV update process started at Thu Feb 15 18:25:17 2018
Downloading main.cvd [100%]
main.cvd updated (version: 58, sigs: 4566249, f-level: 60, builder: sigmgr)
Downloading daily.cvd [100%]
daily.cvd updated (version: 24010, sigs: 1769510, f-level: 63, builder: neo)
Downloading bytecode.cvd [100%]
bytecode.cvd updated (version: 315, sigs: 75, f-level: 63, builder: raynman)
...
systemctl start clamav-freshclam

Ensuite on démarre le daemon :

systemctl start clamav-daemon

Il faut donner les droits clamv aux dossiers

chown -R clamav:clamav /var/lib/clamav
chown -R clamav:clamav /var/log/clamav

Fail2ban

Fail2ban

Fail2ban lit des fichiers de log et bannit les adresses IP qui ont obtenu un trop grand nombre d’échecs lors de l’authentification. Il met à jour les règles du pare-feu pour rejeter cette adresse IP. Ces règles peuvent êtres défines par l’utilisateur.

Les commandes sont exécutées en mode su sudo

Installation

apt install fail2ban

fail2ban.conf

Rien à faire dans ce fichier, vous pouvez laisser les options par défaut:

nano /etc/fail2ban/fail2ban.conf
[Definition]

# Option: loglevel
# Notes.: Set the log level output.
#         CRITICAL
#         ERROR
#         WARNING
#         NOTICE
#         INFO
#         DEBUG
# Values: [ LEVEL ]  Default: ERROR
#
loglevel = INFO

# Option: logtarget
# Notes.: Set the log target. This could be a file, SYSLOG, STDERR or STDOUT.
#         Only one log target can be specified.
#         If you change logtarget from the default value and you are
#         using logrotate -- also adjust or disable rotation in the
#         corresponding configuration file
#         (e.g. /etc/logrotate.d/fail2ban on Debian systems)
# Values: [ STDOUT | STDERR | SYSLOG | FILE ]  Default: STDERR
#
logtarget = /var/log/fail2ban.log

# Option: socket
# Notes.: Set the socket file. This is used to communicate with the daemon. Do
#         not remove this file when Fail2ban runs. It will not be possible to
#         communicate with the server afterwards.
# Values: [ FILE ]  Default: /var/run/fail2ban/fail2ban.sock
#
socket = /var/run/fail2ban/fail2ban.sock

# Option: pidfile
# Notes.: Set the PID file. This is used to store the process ID of the
#         fail2ban server.
# Values: [ FILE ]  Default: /var/run/fail2ban/fail2ban.pid
#
pidfile = /var/run/fail2ban/fail2ban.pid

# Options: dbfile
# Notes.: Set the file for the fail2ban persistent data to be stored.
#         A value of ":memory:" means database is only stored in memory
#         and data is lost when fail2ban is stopped.
#         A value of "None" disables the database.
# Values: [ None :memory: FILE ] Default: /var/lib/fail2ban/fail2ban.sqlite3
dbfile = None

jail.conf

Copier la configuration par défaut afin qu’elle ne soit pas supprimée en cas de mise à jour.

cp /etc/fail2ban/jail.conf  /etc/fail2ban/jail.local

Ce fichier est beaucoup plus intéressant, il contient tous les services à monitorer, et vous allez le découvrir, fail2ban ne se limite pas à SSH…

nano /etc/fail2ban/jail.local

Tous les commentaires ont été supprimés pour allèger le fichier.
Les commentaires sont visibles dans le fichier original jail.conf

[INCLUDES]

before = paths-debian.conf

[DEFAULT]

ignoreip = 127.0.0.1/8
bantime  = 600
findtime  = 600
maxretry = 3
backend = auto
usedns = warn
logencoding = auto
filter = %(__name__)s

destemail = root@localhost
sender = root@localhost
mta = sendmail
protocol = tcp
chain = INPUT
port = 0:65535
fail2ban_agent = Fail2Ban/%(fail2ban_version)s

banaction = iptables-multiport
banaction_allports = iptables-allports
protocol="%(protocol)s", chain="%(chain)s"]
action_mw = %(banaction)s[name=%(__name__)s, bantime="%(bantime)s", port="%(port)s", protocol="%(protocol)s", chain="%(chain)s"]
            %(mta)s-whois[name=%(__name__)s, sender="%(sender)s", dest="%(destemail)s", protocol="%(protocol)s", chain="%(chain)s"]

action_mwl = %(banaction)s[name=%(__name__)s, bantime="%(bantime)s", port="%(port)s", protocol="%(protocol)s", chain="%(chain)s"]
             %(mta)s-whois-lines[name=%(__name__)s, sender="%(sender)s", dest="%(destemail)s", logpath=%(logpath)s, chain="%(chain)s"]

action_xarf = %(banaction)s[name=%(__name__)s, bantime="%(bantime)s", port="%(port)s", protocol="%(protocol)s", chain="%(chain)s"]
             xarf-login-attack[service=%(__name__)s, sender="%(sender)s", logpath=%(logpath)s, port="%(port)s"]

action_cf_mwl = cloudflare[cfuser="%(cfemail)s", cftoken="%(cfapikey)s"]
                %(mta)s-whois-lines[name=%(__name__)s, sender="%(sender)s", dest="%(destemail)s", logpath=%(logpath)s, chain="%(chain)s"]

action_blocklist_de  = blocklist_de[email="%(sender)s", service=%(filter)s, apikey="%(blocklist_de_apikey)s", agent="%(fail2ban_agent)s"]

action_badips = badips.py[category="%(__name__)s", banaction="%(banaction)s", agent="%(fail2ban_agent)s"]
action_badips_report = badips[category="%(__name__)s", agent="%(fail2ban_agent)s"]

action = %(action_)s

Pour envoyer un mail contenant le whois, placez la variable sur :

action = %(action_mw)s

Pour envoyer un mail avec le whois ET les logs, placez la variable sur :

action = %(action_mwl)s

Pour activer la surveillance d’un service, il suffit de placer la variable “enabled” à “true”

Par défaut la protection du service SSH est activée, pas les autres.

Si votre ssh n’écoute pas sur le port 22, pensez à le changer… (port = N° de port).

Rappelez vous également que le loglevel de SSHD (/etc/ssh/sshd_config) doit absolument être positionné sur DEBUG (LogLevel DEBUG) sans quoi, Fail2ban ne bloquera rien concernant SSH.

#
# JAILS
#

# SSH
[sshd]

enabled = true
port    = 55026
logpath = %(sshd_log)s
backend = %(sshd_backend)s

# Mail servers
[postfix]

enabled  = true
port     = smtp,ssmtp,submission
filter   = postfix
logpath  = /var/log/mail.log

[sasl]

enabled  = true
port     = smtp,ssmtp,submission,imap2,imap3,imaps,pop3,pop3s
filter   = postfix-sasl
# You might consider monitoring /var/log/mail.warn instead if you are
# running postfix since it would provide the same log lines at the
# "warn" level but overall at the smaller filesize.
logpath  = /var/log/mail.log

[dovecot]

enabled = true
port    = smtp,ssmtp,submission,imap2,imap3,imaps,pop3,pop3s
filter  = dovecot
logpath = /var/log/mail.log

# nginx
[nginx-http-auth]

enabled = true
port    = http,https
logpath = %(nginx_error_log)s

Redémarrer fail2ban pour implémenter les règles:

sytemctl restart fail2ban

Afficher les règles de pare-feu actuelles

sudo iptables -S
-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N f2b-dovecot
-N f2b-nginx-http-auth
-N f2b-postfix
-N f2b-sasl
-N f2b-sshd
-A INPUT -p tcp -m multiport --dports 25,465,587 -j f2b-postfix
-A INPUT -p tcp -m multiport --dports 80,443 -j f2b-nginx-http-auth
-A INPUT -p tcp -m multiport --dports 55026 -j f2b-sshd
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -p icmp -j ACCEPT
-A INPUT -p tcp -m tcp --dport 55026 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 53 -j ACCEPT
-A INPUT -p udp -m udp --dport 53 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 443 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 993 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 587 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 25 -j ACCEPT
-A OUTPUT -o lo -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 55026 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 53 -j ACCEPT
-A OUTPUT -p udp -m udp --dport 53 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 443 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 993 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 587 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 25 -j ACCEPT
-A f2b-dovecot -j RETURN
-A f2b-nginx-http-auth -j RETURN
-A f2b-postfix -j RETURN
-A f2b-sasl -j RETURN
-A f2b-sshd -j RETURN

Clients de messagerie

Rainloop (webmail)

webmail rainloop

Rainloop est un webmail opensource développé en PHP qui se veut complet et simple d’utilisation. Il gère très bien les protocoles IMAP/SMTP et dispose d’une interface moderne (HTML5/CSS3) très érgonomique, c’est plutôt agréable. Du côté des fonctionnalités, on retrouve toutes celles d’un client mail classique, avec en plus un système de plugins.

Rainloop est très simple à mettre en place. Téléchargez le zip depuis le site officiel et décompressez-le dans le dossier /var/www/rainloop :

wget https://www.rainloop.net/repository/webmail/rainloop-community-latest.zip
mkdir /var/www/rainloop
unzip rainloop-community-latest.zip -d /var/www/rainloop
rm -rf rainloop-community-latest.zip

Modifiez les permissions pour que le serveur web ait accès au répertoire /var/www/rainloop

cd /var/www/rainloop
find . -type d -exec chmod 755 {} \;
find . -type f -exec chmod 644 {} \;
chown -R www-data:www-data .

Ajouter un nouveau virtual host Nginx (à adapter selon votre configuration) :

mkdir -p /etc/nginx/conf.d/webmail.xoyize.xyz.d
nano /etc/nginx/conf.d/webmail.xoyize.xyz.conf
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name webmail.xoyize.xyz;

    ####    Locations
    # On cache les fichiers statiques
    location ~* \.(html|css|js|png|jpg|jpeg|gif|ico|svg|eot|woff|ttf)$ { expires max; }
    # On interdit les dotfiles
    location ~ /\. { deny all; }

    include ssl_params;
    include header_params;
    include dh_param;

    root /var/www/rainloop ;
    index index.php index.html index.htm;
        location ~ \.php$ {
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           fastcgi_pass unix:/run/php/php7.0-fpm.sock;    # PHP7.0
           fastcgi_index index.php;
           include fastcgi_params;
	   fastcgi_param SCRIPT_FILENAME $request_filename;
        }

    include conf.d/webmail.xoyize.xyz.d/*.conf;

    access_log /var/log/nginx/webmail.xoyize.xyz-access.log;
    error_log /var/log/nginx/webmail.xoyize.xyz-error.log;
}

Relancer le service nginx

systemctl restart nginx

Connexion à l’interface d’administration via le lien https://webmail.xoyize.xyz/?admin
Par défaut les identifiants sont : admin et 12345

Modifier le mot de passe “admin”
Une fois connecté à l’interface d’administration, vous devez ajouter un nouveau domaine. Dans le menu de gauche cliquez sur Domaines puis sur + Ajouter un domaine. Une nouvelle fenêtre s’ouvre et vous demande de configurer IMAP et SMTP pour ce domaine.
IMAP xoyize.xyz 993 SSL/TLS
SMTP xoyize.xyz 587 STARTTLS

rainloop domaine

Une fois les champs remplis, cliquez sur le bouton “Test Connection” pour voir si vous n’avez pas fait d’erreur de saisie. N’hésitez pas à lancer en même temps la commande tail si vous avez des problèmes de connexion :

tail -f /var/log/mail.log

Ajoutez tous les utilisateurs autorisés à se connecter dans le White List (bouton en bas), par exemple pour admin@xoyize.xyz et yan@xoyize.xyz vous devez mettre (les utilisateurs sont séparés par des espaces) :

admin yan

Voir les autres sections de l’espace d’administration pour une personnalisation.
Activation des logs

nano nano /var/www/rainloop/data/_data_/_default_/configs/application.ini
[logs]
; Enable logging
enable = On

Thunderbird (linux), K9mail (Android)

La configuration d’un client mail reste relativement simple, il ne faut juste pas se tromper de port :

thunderbird

IMAP  imap.xoyize.xyz ou xoyize.xyz 993  SSL/TLS   Normal Password
SMTP  smtp.xoyize.xyz ou xoyize.xyz 587  STARTTLS  Normal Password
Utilisateur yan@xoyize.xyz

Les adresses imap.xoyize.xyz et smtp.xoyize.xyz sont arbitraires, vous pouvez très bien mettre à la place le FQDN de votre serveur (exemple: xoyize.xyz), ça marchera très bien aussi. Le plus important ce sont les ports et les algorithmes de chiffrement/d’authentification (SSL/TLS - STARTTLS).

Tests

Tester avec la commande openssl

openssl s_client -connect xoyize.xyz:587 -starttls smtp -tlsextdebug # Postfix

Il faut vérifier la chaîne :

---
Certificate chain
 0 s:/CN=xoyize.xyz
   i:/C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3
 1 s:/C=US/O=Let's Encrypt/CN=Let's Encrypt Authority X3
   i:/O=Digital Signature Trust Co./CN=DST Root CA X3
---

Puis taper QUIT

openssl s_client -connect xoyize.xyz:993 -tlsextdebug # Dovecot

Dans le cas de IMAP, le serveur devrait répondre :

* OK [CAPABILITY IMAP4rev1 LITERAL+ SASL-IR LOGIN-REFERRALS ID ENABLE IDLE AUTH=PLAIN AUTH=LOGIN] Dovecot ready.

Puis taper QUIT

Nextcloud

Installation

Prérequis

Base Mysql/Mariadb

Installer la dernière version nextcloud

cd /var/www
wget https://download.nextcloud.com/server/releases/nextcloud-13.0.0.zip
unzip nextcloud-13.0.0.zip
mkdir /var/www/nextcloud/data
rm nextcloud-13.0.0.zip
useradd nextcloud --comment "limited nextcloud user" --no-create-home
chown -R nextcloud:www-data /var/www/nextcloud
chmod -R o-rwx /var/www/nextcloud

Création du pool dédié à Nextcloud

nano /etc/php/7.0/fpm/pool.d/nextcloud.conf
[nextcloud]

listen = /run/php/php7.0-fpm-nextcloud.sock

; Set permissions for unix socket, if one is used.
listen.owner = nextcloud
listen.group = www-data
listen.mode = 0660

; Unix user/group of processes.
user = nextcloud
group = www-data

pm = dynamic
pm.max_children = 6
pm.start_servers = 3
pm.min_spare_servers = 3
pm.max_spare_servers = 5
pm.max_requests = 500
pm.status_path = /fpm-status
ping.path = /ping
request_terminate_timeout = 1d
request_slowlog_timeout = 5s
slowlog = /var/log/nginx/nextcloud.slow.log
rlimit_files = 4096
rlimit_core = 0
chdir = /var/www/nextcloud/
catch_workers_output = yes
clear_env = no

php_value[upload_max_filesize] = 10G
php_value[post_max_size] = 10G
php_value[default_charset] = UTF-8

Redémarrez le service php-fpm afin d’activer le nouveau pool nextcloud :

systemctl restart php7.0-fpm.service

La configuration vhost

nano /etc/nginx/conf.d/xoyize.xyz.d/nextcloud.conf
location ^~ /nextcloud {
  alias /var/www/nextcloud/;

  if ($scheme = http) {
    rewrite ^ https://$server_name$request_uri? permanent;
  }

    # Add headers to serve security related headers
    add_header                    X-Content-Type-Options nosniff;
    add_header                    X-XSS-Protection "1; mode=block";
    add_header                    X-Robots-Tag none;
    add_header                    X-Download-Options noopen;
    add_header                    X-Permitted-Cross-Domain-Policies none;
    add_header                    Strict-Transport-Security 'max-age=31536000; includeSubDomains;';

  # Set max upload size
  client_max_body_size 10G;
  fastcgi_buffers 64 4K;

  # Disable gzip to avoid the removal of the ETag header
  gzip off;

  # Errors pages
  error_page 403 /nextcloud/core/templates/403.php;
  error_page 404 /nextcloud/core/templates/404.php;

  # The following 2 rules are only needed for the user_webfinger app.
  # Uncomment it if you're planning to use this app.
  #rewrite ^/.well-known/host-meta /nextcloud/public.php?service=host-meta last;
  #rewrite ^/.well-known/host-meta.json /nextcloud/public.php?service=host-meta-json last;

  location /nextcloud {
    rewrite ^ /nextcloud/index.php$uri;
  }

  location = /nextcloud/robots.txt {
    allow all;
    log_not_found off;
    access_log off;
  }

  location ~ ^/nextcloud/(?:build|tests|config|lib|3rdparty|templates|data)/ {
    deny all;
  }
  location ~ ^/nextcloud/(?:\.|autotest|occ|issue|indie|db_|console) {
    deny all;
  }

  location ~ ^/nextcloud/(?:index|remote|public|cron|core/ajax/update|status|ocs/v[12]|updater/.+|ocs-provider/.+|core/templates/40[34])\.php(?:$|/) {
    include fastcgi_params;
    fastcgi_split_path_info ^(.+\.php)(/.+)$;
    fastcgi_param SCRIPT_FILENAME $request_filename;
    fastcgi_param PATH_INFO $fastcgi_path_info;
    fastcgi_param HTTPS on;
    fastcgi_param modHeadersAvailable true;
    fastcgi_param REMOTE_USER $remote_user;
    fastcgi_pass unix:/run/php/php7.0-fpm-nextcloud.sock;
    fastcgi_intercept_errors on;
  }

  location ~ ^/nextcloud/(?:updater|ocs-provider)(?:$|/) {
    try_files $uri/ =404;
    index index.php;
  }

  # Adding the cache control header for js and css files
  location ~* \.(?:css|js)$ {
    add_header Cache-Control "public, max-age=7200";
    # Add headers to serve security related headers
    add_header Strict-Transport-Security "max-age=15768000;";
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Robots-Tag none;
    add_header X-Download-Options noopen;
    add_header X-Permitted-Cross-Domain-Policies none;
    # Optional: Don't log access to assets
    access_log off;
  }

  location ~* \.(?:svg|gif|png|html|ttf|woff|ico|jpg|jpeg)$ {
    # Optional: Don't log access to other assets
    access_log off;
  }

}

Vérification

nginx -t
	nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
	nginx: configuration file /etc/nginx/nginx.conf test is successful

Relancer php-fpm et nginx

systemctl restart php7.0-fpm nginx

Accès https://xoyize.xyz/nextcloud

Créer un compte administrateur admin + mot de passe
Répertoire des données /var/www/nextcloud/data
Base MariaDb (MySql) nextcloud , utilisateur nextcloud + mot de passe accès

Les caches

Nextcloud Debian Stretch: les caches

Après installation du cache ,se connecter en admin , Paramètres -> Paramètres de base

Avertissements de sécurité & configuration

Il est important pour la sécurité et la performance de votre instance que tout soit configuré correctement. Pour vous aider dans cette tâche, nous faisons des vérifications automatiques. Veuillez consulter la section Trucs et Astuces et la documentation pour plus d'informations.

x Tous les tests ont réussi.

Activer la double authentification (admin)

Administration , Outils “Two Factor TOTP Provider” : Activer

2fa

Complément
Administartion ,Paramètres Sécurité
Générer des codes de récupération

2fa

Deuxième facteur d’authentification du mot de passe temporaire à usage unique x Activer les mots de passe à usage unique (TOTP) Votre nouveau secret TOTP est : kfkfiiehhdyyhdkz Scannez ce QR code avec votre application TOTP (android)

2fa

Enter un code pour confirmer le passage en double authentification

Utilisateur, Calendar, Contacts et Mail

Connexion admin

Créer un groupe users et ajouter un utilisateur yan à ce groupe

Administration, +Applications, Pack d’applications
Calendar : Activer
Contacts : Activer
External storage support :Activer

Administration, +Applications, Bureautique &Texte “Mail” : Activer

icones

Stockage externe

externe

Connexion utilisateur yan

Messagerie : Cliquer sur l’icône icone mail (en haut à gauche de l’écran) et compléter

Mail

Calendrier : Cliquer sur l’icône icone mail et renommer l’agenda yan

Contacts : Cliquer sur l’icône icone mail et renommer le carnet d’adresses yan

Activer l’authentification en deux étapes, avec les codes de récupération, pour l’utilisateur yan , Personnel -> Sécurité
Pour utiliser la synchronisation client , il faut aller dans Paramètres -> Sécurité et cliquer syr Créer un nouveau mot de passe d’application
Ce sera le mot de passe à utiliser pour la synchronisation de fichiers/dossiers (Impératif quand on active la double authentification)

mp appli

Nextcloud nc.xoyize.xyz

Pour afficher la page de connexion Nextcloud sur https://nc.xoyize.xyz
Créer le fichier /etc/nginx/conf.d/nc.xoyize.xyz.conf avec le contenu suivant

upstream php-handler {
    #server 127.0.0.1:9000;
    server unix:/run/php/php7.0-fpm-nextcloud.sock;    # PHP7.0
}

server {
    listen 80;
    listen [::]:80;
    server_name nc.xoyize.xyz;
    # enforce https
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name nc.xoyize.xyz;

    include ssl_params;
    include dh_param;

    # Add headers to serve security related headers
    # Before enabling Strict-Transport-Security headers please read into this
    # topic first.
    # add_header Strict-Transport-Security "max-age=15768000;
    # includeSubDomains; preload;";
    #
    # WARNING: Only add the preload option once you read about
    # the consequences in https://hstspreload.org/. This option
    # will add the domain to a hardcoded list that is shipped
    # in all major browsers and getting removed from this list
    # could take several months.
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Robots-Tag none;
    add_header X-Download-Options noopen;
    add_header X-Permitted-Cross-Domain-Policies none;

    # Path to the root of your installation
    root /var/www/nextcloud/;

    location = /robots.txt {
        allow all;
        log_not_found off;
        access_log off;
    }

    # The following 2 rules are only needed for the user_webfinger app.
    # Uncomment it if you're planning to use this app.
    #rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
    #rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json
    # last;

    location = /.well-known/carddav {
      return 301 $scheme://$host/remote.php/dav;
    }
    location = /.well-known/caldav {
      return 301 $scheme://$host/remote.php/dav;
    }

    # set max upload size
    client_max_body_size 512M;
    fastcgi_buffers 64 4K;

    # Enable gzip but do not remove ETag headers
    gzip on;
    gzip_vary on;
    gzip_comp_level 4;
    gzip_min_length 256;
    gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
    gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;

    # Uncomment if your server is build with the ngx_pagespeed module
    # This module is currently not supported.
    #pagespeed off;

    location / {
        rewrite ^ /index.php$uri;
    }

    location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
        deny all;
    }
    location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
        deny all;
    }

    location ~ ^/(?:index|remote|public|cron|core/ajax/update|status|ocs/v[12]|updater/.+|ocs-provider/.+)\.php(?:$|/) {
        fastcgi_split_path_info ^(.+\.php)(/.*)$;
        include fastcgi_params;
        #fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
         fastcgi_param SCRIPT_FILENAME $request_filename;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_param HTTPS on;
        #Avoid sending the security headers twice
        fastcgi_param modHeadersAvailable true;
         fastcgi_param REMOTE_USER $remote_user;
        fastcgi_param front_controller_active true;
        fastcgi_pass php-handler;
        fastcgi_intercept_errors on;
        fastcgi_request_buffering off;
    }

    location ~ ^/(?:updater|ocs-provider)(?:$|/) {
        try_files $uri/ =404;
        index index.php;
    }

    # Adding the cache control header for js and css files
    # Make sure it is BELOW the PHP block
    location ~ \.(?:css|js|woff|svg|gif)$ {
        try_files $uri /index.php$uri$is_args$args;
        add_header Cache-Control "public, max-age=15778463";
        # Add headers to serve security related headers (It is intended to
        # have those duplicated to the ones above)
        # Before enabling Strict-Transport-Security headers please read into
        # this topic first.
        # add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload;";
        #
        # WARNING: Only add the preload option once you read about
        # the consequences in https://hstspreload.org/. This option
        # will add the domain to a hardcoded list that is shipped
        # in all major browsers and getting removed from this list
        # could take several months.
        add_header X-Content-Type-Options nosniff;
        add_header X-XSS-Protection "1; mode=block";
        add_header X-Robots-Tag none;
        add_header X-Download-Options noopen;
        add_header X-Permitted-Cross-Domain-Policies none;
        # Optional: Don't log access to assets
        access_log off;
    }

    location ~ \.(?:png|html|ttf|ico|jpg|jpeg)$ {
        try_files $uri /index.php$uri$is_args$args;
        # Optional: Don't log access to other assets
        access_log off;
    }
}

IL faut modifier le fichier de configuration de nextcloud

  'trusted_domains' => 
  array (
    0 => 'nc.xoyize.xyz',
  ),
  'datadirectory' => '/var/www/nextcloud/data',
  'overwrite.cli.url' => 'https://nc.xoyize.xyz',

Vérification et relance nginx

nginx -t
systemctl restart nginx