Lundi 19 février 2018

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

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

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”

Debian Màj

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.