Guide Avancé de Sécurisation VPS : Protégez Votre Serveur comme un Pro

Une configuration VPS basique vous laisse exposé. Les configurations par défaut, les ports ouverts et l’authentification faible sont une invitation aux attaques. Ce guide va au-delà des bases — renforcement du noyau, détection d’intrusion, blocage automatisé et journalisation d’audit qui détecte réellement les menaces.

Vous avez déjà des clés SSH et un pare-feu ? Parfait. Ce guide reprend là où les guides pour débutants s’arrêtent.

Ce que couvre ce guide

Couche	Outils	Objectif
Réseau	UFW, iptables, fail2ban	Bloquer les accès non autorisés
Authentification	Renforcement SSH, 2FA	Empêcher les attaques par force brute
Noyau	Tuning sysctl	Réduire la surface d’attaque
Contrôle d’accès obligatoire	AppArmor / SELinux	Contenir les services compromis
Détection d’intrusion	AIDE, auditd	Détecter les modifications non autorisées
Journalisation	rsyslog, logwatch	Tout surveiller
Mises à jour automatiques	unattended-upgrades	Corriger les vulnérabilités

Prérequis

• Un VPS sous Ubuntu 22.04+ ou Debian 12+ (la plupart des exemples fonctionnent sur RHEL/Rocky avec quelques ajustements)
• Authentification par clé SSH déjà configurée
• Accès root ou sudo
• Familiarité de base avec la ligne de commande Linux

Fournisseurs VPS recommandés pour les utilisateurs soucieux de la sécurité :

Fournisseur	Pourquoi	Prix de départ
Hetzner	Centres de données en UE, conforme au RGPD, performances brutes	3,79€/mois
Hostinger	KVM abordable avec sauvegardes par snapshot	4,99$/mois
Vultr	Options bare metal, protection DDoS incluse	6$/mois
DigitalOcean	Réseau VPC, pare-feu managés	6$/mois

1. Renforcement SSH (au-delà des bases)

Vous avez déjà l’authentification par clé. Maintenant, verrouillons davantage.

Restreindre SSH aux clés uniquement, désactiver root

sudo nano /etc/ssh/sshd_config

Définissez ces valeurs :

# Authentification
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AuthenticationMethods publickey

# Limiter l'exposition
MaxAuthTries 3
MaxSessions 3
LoginGraceTime 30
ClientAliveInterval 300
ClientAliveCountMax 2

# Désactiver les fonctionnalités inutiles
X11Forwarding no
AllowTcpForwarding no
AllowAgentForwarding no
PermitTunnel no

# Utiliser uniquement des algorithmes robustes
KexAlgorithms skedf25519-sha256,skedf25519-sha256@libssh.org,diffie-hellman-group16-sha512
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

Changer le port SSH par défaut

Déplacer SSH du port 22 arrête la plupart des scans automatisés :

# Ajouter le nouveau port (ne supprimez pas encore le 22 !)
Port 2222
Port 22

Redémarrez et testez avec le nouveau port avant de supprimer le 22 :

sudo systemctl restart sshd
ssh -p 2222 user@your-server

Une fois confirmé, supprimez Port 22 et redémarrez à nouveau.

Ajouter l’authentification à deux facteurs

sudo apt install libpam-google-authenticator
google-authenticator

Modifiez la configuration PAM :

sudo nano /etc/pam.d/sshd

Ajoutez en haut :

auth required pam_google_authenticator.so

Mettez à jour sshd_config :

AuthenticationMethods publickey,keyboard-interactive
ChallengeResponseAuthentication yes

Désormais, la connexion nécessite à la fois votre clé SSH et un code TOTP.

2. Configuration du pare-feu avec UFW + limitation de débit

Configuration de base d’UFW

sudo ufw default deny incoming
sudo ufw default allow outgoing

# Autoriser SSH (utilisez votre port personnalisé)
sudo ufw limit 2222/tcp comment 'SSH rate-limited'

# Autoriser le trafic web
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'

# Activer
sudo ufw enable

La règle limit limite automatiquement le débit de connexions — 6 connexions par 30 secondes, puis blocage.

Avancé : règles iptables pour l’atténuation DDoS

Pour les serveurs à fort trafic, ajoutez ces règles iptables :

# Rejeter les paquets invalides
sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

# Bloquer le scan de ports
sudo iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
sudo iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP

# Limiter le débit des nouvelles connexions (protection contre les SYN flood)
sudo iptables -A INPUT -p tcp --syn -m limit --limit 25/second --limit-burst 50 -j ACCEPT
sudo iptables -A INPUT -p tcp --syn -j DROP

# Limiter ICMP (protection contre les ping flood)
sudo iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j ACCEPT
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

Sauvegardez les règles pour qu’elles persistent après redémarrage :

sudo apt install iptables-persistent
sudo netfilter-persistent save

3. Fail2Ban : protection intelligente contre la force brute

Installation et configuration

sudo apt install fail2ban
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

Modifiez /etc/fail2ban/jail.local :

[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 3
banaction = ufw
backend = systemd

# Notifications par email (optionnel)
destemail = you@example.com
action = %(action_mwl)s

[sshd]
enabled = true
port = 2222
maxretry = 3
bantime = 86400

[sshd-ddos]
enabled = true
port = 2222

# Protéger nginx
[nginx-http-auth]
enabled = true
filter = nginx-http-auth
logpath = /var/log/nginx/error.log
maxretry = 3

[nginx-botsearch]
enabled = true
filter = nginx-botsearch
logpath = /var/log/nginx/access.log
maxretry = 2

# Protéger contre les 404 répétés (scanners)
[nginx-404]
enabled = true
port = http,https
filter = nginx-404
logpath = /var/log/nginx/access.log
maxretry = 10
findtime = 60
bantime = 3600

Créez le filtre nginx-404 :

sudo nano /etc/fail2ban/filter.d/nginx-404.conf

[Definition]
failregex = ^<HOST> .* "(GET|POST|HEAD).*" 404
ignoreregex =

Démarrez fail2ban :

sudo systemctl enable fail2ban
sudo systemctl start fail2ban
sudo fail2ban-client status

4. Renforcement du noyau avec sysctl

Ces paramètres réduisent la surface d’attaque de votre noyau :

sudo nano /etc/sysctl.d/99-hardening.conf

# Désactiver le transfert IP (sauf si vous utilisez Docker/VPN)
net.ipv4.ip_forward = 0
net.ipv6.conf.all.forwarding = 0

# Empêcher l'usurpation d'IP
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# Ignorer les redirections ICMP
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0

# Ne pas envoyer de redirections ICMP
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

# Ignorer les paquets routés par la source
net.ipv4.conf.all.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0

# Activer les SYN cookies (protection contre les SYN flood)
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 2048
net.ipv4.tcp_synack_retries = 2

# Journaliser les paquets suspects
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# Désactiver IPv6 si non nécessaire
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1

# Renforcer le noyau
kernel.randomize_va_space = 2
kernel.kptr_restrict = 2
kernel.dmesg_restrict = 1
kernel.perf_event_paranoid = 3
kernel.yama.ptrace_scope = 2

# Restreindre les espaces de noms utilisateur non privilégiés
kernel.unprivileged_userns_clone = 0

# Renforcement du système de fichiers
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
fs.suid_dumpable = 0

Appliquez immédiatement :

sudo sysctl --system

Utilisateurs Docker : Gardez net.ipv4.ip_forward = 1 si vous exécutez des conteneurs. Docker en a besoin pour le réseau.

5. AppArmor : contrôle d’accès obligatoire

AppArmor confine les programmes à un ensemble limité de ressources — même si un attaquant exploite une vulnérabilité, il ne peut pas s’échapper du profil.

Activer et vérifier l’état

sudo apt install apparmor apparmor-utils apparmor-profiles apparmor-profiles-extra
sudo aa-status

Appliquer les profils pour les services clés

# Lister les profils disponibles
sudo aa-unconfined

# Mettre nginx en mode enforce
sudo aa-enforce /etc/apparmor.d/usr.sbin.nginx

# Créer un profil pour une application personnalisée
sudo aa-genprof /usr/local/bin/myapp

Créer des profils personnalisés

Pour les applications sans profil existant :

# Démarrer en mode complain (journalise les violations mais ne bloque pas)
sudo aa-complain /path/to/application

# Exécutez l'application normalement, testez toutes les fonctionnalités
# Puis examinez les journaux et passez en mode enforce
sudo aa-logprof
sudo aa-enforce /path/to/application

6. Détection d’intrusion avec AIDE

AIDE (Advanced Intrusion Detection Environment) surveille l’intégrité des fichiers — il vous alerte lorsque des fichiers système changent de manière inattendue.

Installation et initialisation

sudo apt install aide
sudo aideinit
sudo cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db

Configurer ce qu’il faut surveiller

sudo nano /etc/aide/aide.conf

Ajoutez des règles personnalisées :

# Surveiller les répertoires système critiques
/etc p+i+u+g+sha256
/bin p+i+u+g+sha256
/sbin p+i+u+g+sha256
/usr/bin p+i+u+g+sha256
/usr/sbin p+i+u+g+sha256

# Surveiller la racine web
/var/www p+i+u+g+sha256

# Exclure les répertoires bruyants
!/var/log
!/var/cache
!/tmp

Automatiser les vérifications quotidiennes

sudo crontab -e

Ajoutez :

0 5 * * * /usr/bin/aide --check | mail -s "AIDE Report $(hostname)" you@example.com

7. Journalisation d’audit avec auditd

Suivez qui fait quoi sur votre système :

sudo apt install auditd audispd-plugins

Ajouter des règles d’audit

sudo nano /etc/audit/rules.d/hardening.rules

# Surveiller l'authentification
-w /etc/pam.d/ -p wa -k auth_changes
-w /etc/shadow -p wa -k shadow_changes
-w /etc/passwd -p wa -k passwd_changes

# Surveiller la configuration SSH
-w /etc/ssh/sshd_config -p wa -k sshd_config

# Surveiller l'utilisation de sudo
-w /var/log/auth.log -p wa -k auth_log
-w /etc/sudoers -p wa -k sudoers

# Surveiller cron
-w /etc/crontab -p wa -k cron_changes
-w /etc/cron.d/ -p wa -k cron_changes
-w /var/spool/cron/ -p wa -k cron_changes

# Surveiller la configuration réseau
-w /etc/hosts -p wa -k hosts_changes
-w /etc/network/ -p wa -k network_changes

# Surveiller les modules du noyau
-w /sbin/insmod -p x -k kernel_modules
-w /sbin/modprobe -p x -k kernel_modules
-w /sbin/rmmod -p x -k kernel_modules

# Journaliser toutes les commandes exécutées par root
-a always,exit -F arch=b64 -F euid=0 -S execve -k root_commands

# Rendre les règles immuables (nécessite un redémarrage pour les modifier)
-e 2

Redémarrez auditd :

sudo systemctl restart auditd

Recherchez dans les journaux d’audit :

# Trouver tous les événements sudo
sudo ausearch -k sudoers

# Trouver les modifications de configuration SSH
sudo ausearch -k sshd_config

8. Mises à jour de sécurité automatiques

Ne manquez jamais un correctif critique :

sudo apt install unattended-upgrades apt-listchanges
sudo dpkg-reconfigure -plow unattended-upgrades

Configurez ce qui est mis à jour automatiquement :

sudo nano /etc/apt/apt.conf.d/50unattended-upgrades

Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}-security";
    "${distro_id}ESMApps:${distro_codename}-apps-security";
};

Unattended-Upgrade::AutoFixInterruptedDpkg "true";
Unattended-Upgrade::Remove-Unused-Dependencies "true";
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Automatic-Reboot-Time "04:00";

// Notifications par email
Unattended-Upgrade::Mail "you@example.com";
Unattended-Upgrade::MailReport "on-change";

9. Sécuriser la mémoire partagée et /tmp

Empêchez les attaques sur la mémoire partagée :

sudo nano /etc/fstab

Ajoutez :

tmpfs /run/shm tmpfs defaults,noexec,nosuid,nodev 0 0
tmpfs /tmp tmpfs defaults,noexec,nosuid,nodev,size=2G 0 0

Remontez :

sudo mount -o remount /run/shm
sudo mount -o remount /tmp

Remarque : noexec sur /tmp peut casser certains installateurs. Remontez temporairement avec exec si nécessaire : sudo mount -o remount,exec /tmp

10. Surveillance des journaux avec Logwatch

Recevez des résumés de sécurité quotidiens :

sudo apt install logwatch

Configurez :

sudo nano /etc/logwatch/conf/logwatch.conf

Output = mail
MailTo = you@example.com
Detail = High
Range = yesterday
Service = All

Testez :

sudo logwatch --detail High --mailto you@example.com --range today

Checklist de sécurité

Passez en revue cette liste après la sécurisation :

Vérification	Commande	Résultat attendu
Root SSH désactivé	grep PermitRootLogin /etc/ssh/sshd_config	no
Auth par mot de passe désactivée	grep PasswordAuthentication /etc/ssh/sshd_config	no
Pare-feu actif	sudo ufw status	active
Fail2ban en cours	sudo fail2ban-client status	Jails actives listées
AppArmor chargé	sudo aa-status	Profils en mode enforce
AIDE initialisé	sudo aide --check	Aucun changement inattendu
Mises à jour auto activées	apt-config dump | grep Unattended	"1"
Ports ouverts minimaux	sudo ss -tlnp	Uniquement les ports attendus
Noyau renforcé	sysctl kernel.randomize_va_space	2

Maintenance continue

La sécurisation n’est pas une opération ponctuelle. Planifiez ces tâches :

• Quotidien : Vérifier les bannissements fail2ban (sudo fail2ban-client status sshd)
• Hebdomadaire : Consulter les rapports AIDE, examiner les journaux d’authentification
• Mensuel : Mettre à jour tous les paquets, vérifier les ports ouverts, consulter les nouvelles CVE
• Trimestriel : Auditer les comptes utilisateurs, renouveler les clés SSH, revoir les règles du pare-feu

Meilleurs fournisseurs VPS pour la sécurité

Fournisseur	Fonctionnalités de sécurité	Idéal pour
Hostinger	Isolation KVM, protection DDoS, sauvegardes	Meilleur rapport qualité-prix — sécurité solide à bas coût
Hetzner	Lois de confidentialité UE, pare-feu dédié, snapshots	Déploiements axés sur la confidentialité
Vultr	Protection DDoS, API pare-feu, bare metal	Charges de travail haute sécurité
DigitalOcean	VPC, pare-feu managés, monitoring	Environnements d’équipe
Linode	Atténuation DDoS gratuite, monitoring Longview	Configurations axées sur la surveillance

Hostinger offre le meilleur équilibre entre fonctionnalités de sécurité et prix — la virtualisation KVM assure une isolation complète des autres locataires, et leur système de sauvegarde automatisé vous donne des options de récupération en cas de problème.

Conclusion

Un VPS sécurisé ne se résume pas à exécuter un pare-feu. C’est une superposition de couches : filtrage réseau, contrôles d’authentification, restrictions du noyau, contrôle d’accès obligatoire, surveillance de l’intégrité des fichiers et correctifs automatisés. Chaque couche intercepte ce que les autres manquent.

Commencez par le renforcement SSH et fail2ban (impact immédiat), puis ajoutez le tuning du noyau et AppArmor (protection en profondeur), et terminez avec AIDE et auditd (détection et forensique).

Aucun serveur n’est inviolable. Mais un VPS correctement sécurisé pousse les attaquants à se tourner vers des cibles plus faciles — et c’est l’objectif.