Les 20 meilleures pratiques de sécurité du serveur openssh

OpenSSH est l'implémentation du protocole SSH. OpenSSH est recommandé pour se connecter à distance, faire des sauvegardes, transférer des fichiers à distance via scp ou sftp, et bien plus encore. SSH est parfait pour préserver la confidentialité et l'intégrité des données échangées entre deux réseaux et systèmes. Toutefois, son principal avantage est l'authentification du serveur, grâce à l'utilisation de la cryptographie à clé publique. De temps en temps, il y a rumeurs sur l'exploit OpenSSH zero day. Ce La page montre comment sécuriser votre serveur OpenSSH fonctionnant sur un système Linux ou de type Unix pour améliorer la sécurité de sshd..

Valeurs par défaut d'OpenSSH

• Port TCP - 22
• Fichier de configuration du serveur - sshd_config (situé dans le répertoire /etc/ssh/)
• Fichier de configuration du client - ssh_config (situé dans le répertoire /etc/ssh/)
• Clés privées/pubs des utilisateurs et configuration du client - $HOME/.ssh/ répertoire

1. Utiliser la connexion basée sur la clé publique SSH

Le serveur OpenSSH supporte plusieurs types d'authentification. Il est recommandé d'utiliser une authentification basée sur une clé publique. Tout d'abord, créez la paire de clés en utilisant la commande suivante ssh-keygen sur votre ordinateur de bureau/portable local :

Les clés ssh DSA et RSA 1024 bits ou moins sont considérées comme faibles. Évitez-les. Les clés RSA sont préférées aux clés ECDSA lorsque la rétrocompatibilité est une préoccupation pour les clients ssh. Toutes les clés ssh sont de type ED25519 ou RSA. N'utilisez pas d'autre type.

• trousseau de clés : Configurer un accès SSH sécurisé sans mot de passe pour les scripts de sauvegarde
• sshpass : Se connecter à un serveur SSH / fournir un mot de passe SSH en utilisant un script Shell
• Comment configurer les clés SSH sur un système Linux / Unix ?
• Comment télécharger la clé publique ssh en tant que authorized_key en utilisant l'outil Ansible DevOPS
• Authentification par clé publique SSH sur un serveur Linux/Unix

2. Désactiver la connexion de l'utilisateur root

Avant de désactiver la connexion de l'utilisateur root, assurez-vous que les utilisateurs habituels peuvent se connecter en tant que root. Par exemple, autorisez l'utilisateur vivek à se connecter en tant que root en utilisant la commande sudo.

Comment ajouter l'utilisateur vivek au groupe sudo sur une Debian/Ubuntu ?

Autoriser les membres du groupe sudo à exécuter n'importe quelle commande. Ajouter l'utilisateur vivek au groupe sudo :

Comment ajouter l'utilisateur vivek au groupe sudo sur un serveur CentOS/RHEL

Permet aux personnes du groupe wheel d'exécuter toutes les commandes sur un serveur CentOS/RHEL et Fedora Linux. Utilisez la commande usermod pour ajouter l'utilisateur nommé vivek au groupe wheel :

Tester l'accès sudo et désactiver le login root pour ssh

Testez-le et assurez-vous que l'utilisateur vivek peut se connecter en tant que root ou exécuter la commande en tant que root :

PermitRootLogin no
ChallengeResponseAuthentication no
PasswordAuthentication no
UsePAM no

Voir "Comment désactiver la connexion par mot de passe ssh sous Linux pour augmenter la sécurité" pour plus d'informations.

3. Désactiver la connexion par mot de passe

Toutes les connexions basées sur des mots de passe doivent être désactivées. Seules les connexions basées sur des clés publiques sont autorisées. Ajoutez ce qui suit dans votre fichier sshd_config :

AuthenticationMethods publickey
PubkeyAuthentication yes

Les utilisateurs de l'ancienne version de SSHD sur CentOS 6.x/RHEL 6.x doivent utiliser le paramètre suivant :

PubkeyAuthentication yes

4. Limiter l'accès ssh des utilisateurs

Par défaut, tous les utilisateurs des systèmes peuvent se connecter via SSH en utilisant leur mot de passe ou leur clé publique. Parfois, vous créez un compte d'utilisateur UNIX / Linux à des fins FTP ou de courrier électronique. Cependant, ces utilisateurs peuvent se connecter au système en utilisant SSH. Ils auront un accès complet aux outils du système, y compris les compilateurs et les langages de script tels que Perl, Python, qui peuvent ouvrir des ports réseau et faire beaucoup d'autres choses fantaisistes. Pour permettre uniquement aux utilisateurs root, vivek et jerry d'utiliser le système via SSH, ajoutez ce qui suit à sshd_config :

AllowUsers vivek jerry

Alternativement, vous pouvez autoriser tous les utilisateurs à se connecter via SSH mais refuser seulement quelques utilisateurs, avec la ligne suivante dans sshd_config :

DenyUsers root saroj anjali foo

Vous pouvez également configurer Linux PAM pour autoriser ou refuser la connexion via le serveur sshd. Vous pouvez autoriser une liste de noms de groupes à accéder ou à refuser l'accès au serveur ssh.

5. Désactiver les mots de passe vides

Vous devez interdire explicitement la connexion à distance à partir de comptes avec des mots de passe vides, mettez à jour sshd_config avec la ligne suivante :

PermitEmptyPasswords no

6. Utilisez des mots de passe et des phrases de passe forts pour les utilisateurs/clés ssh.

On ne dira jamais assez combien il est important d'utiliser des mots de passe utilisateur et des phrases de passe forts pour vos clés. L'attaque par force brute fonctionne parce que les utilisateurs utilisent des mots de passe basés sur des dictionnaires. Vous pouvez forcer les utilisateurs à éviter les mots de passe contre une attaque par dictionnaire et utiliser l'outil john the ripper pour découvrir les mots de passe faibles existants. Voici un exemple de générateur de mot de passe aléatoire (à mettre dans votre ~/.bashrc) :

genpasswd() {
	local l=$1
       	[ "$l" == "" ] && l=20
      	tr -dc A-Za-z0-9_ < /dev/urandom | head -c ${l} | xargs
}

Exécutez-le :

uw8CnDVMwC6vOKgW

• Générer un mot de passe aléatoire avec mkpasswd / makepasswd / pwgen
• Linux / UNIX : Générer des mots de passe
• Commande de générateur de mot de passe aléatoire sous Linux

7. Pare-feu SSH port TCP # 22

Vous devez mettre en place un pare-feu pour le port TCP # 22 de ssh en mettant à jour les configurations iptables/ufw/firewall-cmd ou pf du pare-feu. En général, le serveur OpenSSH ne doit accepter que les connexions provenant de votre LAN ou d'autres sites WAN distants. Consultez les exemples de la commande ufw ou de la commande iptables pour plus d'informations.

Configuration de Netfilter (Iptables)

Mettez à jour le fichier /etc/sysconfig/iptables (fichier spécifique à Redhat et à ses amis) pour n'accepter que les connexions provenant de 192.168.1.0/24 et 202.54.1.5/29, entrez :

-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 22 -j ACCEPT
-A RH-Firewall-1-INPUT -s 202.54.1.5/29 -m state --state NEW -p tcp --dport 22 -j ACCEPT

Si vous avez doublé sshd avec IPv6, éditez /etc/sysconfig/ip6tables (fichier spécifique à Redhat et amis), entrez :

 -A RH-Firewall-1-INPUT -s ipv6network::/ipv6mask -m tcp -p tcp --dport 22 -j ACCEPT

Remplacez ipv6network::/ipv6mask par les plages IPv6 réelles.

UFW pour Debian/Ubuntu Linux

UFW est un acronyme pour uncomplicated firewall (pare-feu simple). Il est utilisé pour gérer un pare-feu Linux et vise à fournir une interface facile à utiliser pour l'utilisateur. Utilisez la commande suivante pour accepter le port 22 de 202.54.1.5/29 uniquement :

Configuration du pare-feu *BSD PF

Si vous utilisez le pare-feu PF, mettez à jour le fichier /etc/pf.conf comme suit :

pass in on $ext_if inet proto tcp from {192.168.1.0/24, 202.54.1.5/29} to $ssh_server_ip port ssh flags S/SA synproxy state

8. Modifier le port SSH et limiter la liaison IP

Par défaut, SSH écoute toutes les interfaces et adresses IP disponibles sur le système. Limitez la liaison au port ssh et modifiez le port ssh (de nombreux scripts de forçage de brutes n'essaient de se connecter qu'au port TCP # 22). Pour se lier aux adresses IP 192.168.1.5 et 202.54.1.5 et au port 300, ajoutez ou corrigez la ligne suivante dans sshd_config :

Port 300
ListenAddress 192.168.1.5
ListenAddress 202.54.1.5

Une meilleure approche consiste à utiliser des scripts d'approches proactives tels que fail2ban ou denyhosts lorsque vous souhaitez accepter une connexion à partir d'une adresse IP WAN dynamique.

9. Utiliser des enveloppes TCP (facultatif)

TCP Wrapper est un système ACL de mise en réseau basé sur l'hôte, utilisé pour filtrer l'accès réseau à Internet. OpenSSH supporte les wrappers TCP. Mettez simplement à jour votre fichier /etc/hosts.allow comme suit pour autoriser SSH uniquement à partir des adresses IP 192.168.1.2 et 172.16.23.12 :

sshd : 192.168.1.2 172.16.23.12 

Consultez cette FAQ sur la configuration et l'utilisation des wrappers TCP sous Linux / Mac OS X et les systèmes d'exploitation de type UNIX.

10. Déjouer les attaques par force brute et les craqueurs de SSH

La force brute est une méthode permettant de mettre en échec un schéma cryptographique en essayant un grand nombre de possibilités (combinaison d'utilisateurs et de mots de passe) en utilisant un réseau informatique unique ou distribué. Pour prévenir les attaques par force brute contre SSH, utilisez le logiciel suivant :

• DenyHosts est un outil de sécurité basé sur Python pour les serveurs SSH. Il est destiné à prévenir les attaques par force brute sur les serveurs SSH en surveillant les tentatives de connexion invalides dans le journal d'authentification et en bloquant les adresses IP d'origine.
• Explique comment configurer DenyHosts sous RHEL / Fedora et CentOS Linux.
• Fail2ban est un programme similaire qui empêche les attaques par force brute contre SSH.
• sshguard protéger les hôtes contre les attaques par force brute contre ssh et d'autres services en utilisant pf.
• sécurité/sshblock bloquer les tentatives abusives de connexion SSH.
• Filtre IPQ BDB Peut être considéré comme un fail2ban lite.

11. Limiter le débit du trafic entrant sur le port TCP # 22 (optionnel)

Netfilter et pf fournissent tous deux une option de limitation de débit pour effectuer un simple étranglement des connexions entrantes sur le port # 22.

Exemple d'Iptables

L'exemple suivant abandonne les connexions entrantes qui font plus de 5 tentatives de connexion sur le port 22 dans les 60 secondes :

#!/bin/bash
inet_if=eth1
ssh_port=22
$IPT -I INPUT -p tcp --dport ${ssh_port} -i ${inet_if} -m state --state NEW -m recent  --set
$IPT -I INPUT -p tcp --dport ${ssh_port} -i ${inet_if} -m state --state NEW -m recent  --update --seconds 60 --hitcount 5 -j DROP

Appelez le script ci-dessus à partir de vos scripts iptables. Une autre option de configuration :

$IPT -A INPUT  -i ${inet_if} -p tcp --dport ${ssh_port} -m state --state NEW -m limit --limit 3/min --limit-burst 3 -j ACCEPT
$IPT -A INPUT  -i ${inet_if} -p tcp --dport ${ssh_port} -m state --state ESTABLISHED -j ACCEPT
$IPT -A OUTPUT -o ${inet_if} -p tcp --sport ${ssh_port} -m state --state ESTABLISHED -j ACCEPT
# another one line example
# $IPT -A INPUT -i ${inet_if} -m state --state NEW,ESTABLISHED,RELATED -p tcp --dport 22 -m limit --limit 5/minute --limit-burst 5-j ACCEPT

Voir "Comment limiter les connexions SSH (port TCP 22) avec ufw sur Ubuntu Linux" pour plus d'informations et la page de manuel iptables pour plus de détails.

*BSD PF Exemple

Ce qui suit limite le nombre maximum de connexions par source à 20 et limite le nombre de connexions à 15 dans un intervalle de 5 secondes. Si quelqu'un enfreint nos règles, il sera ajouté à notre table abusive_ips et ne pourra plus établir de nouvelles connexions. Enfin, le mot-clé flush tue tous les états créés par la règle de correspondance qui proviennent de l'hôte qui dépasse ces limites.

sshd_server_ip="202.54.1.5"
table <abusive_ips> persist
block in quick from <abusive_ips>
pass in on $ext_if proto tcp to $sshd_server_ip port ssh flags S/SA keep state (max-src-conn 20, max-src-conn-rate 15/5, overload <abusive_ips> flush)

12. Utiliser le port knocking (facultatif)

Le port frappe est une méthode d'ouverture externe des ports sur un pare-feu en générant une tentative de connexion sur un ensemble de ports fermés préspécifiés. Une fois qu'une séquence correcte de tentatives de connexion est reçue, les règles du pare-feu sont modifiées dynamiquement pour permettre à l'hôte qui a envoyé les tentatives de connexion de se connecter au(x) port(s) spécifique(s). Un exemple de port Knocking pour ssh utilisant iptables :

$IPT -N stage1
$IPT -A stage1 -m recent --remove --name knock
$IPT -A stage1 -p tcp --dport 3456 -m recent --set --name knock2
 
$IPT -N stage2
$IPT -A stage2 -m recent --remove --name knock2
$IPT -A stage2 -p tcp --dport 2345 -m recent --set --name heaven
 
$IPT -N door
$IPT -A door -m recent --rcheck --seconds 5 --name knock2 -j stage2
$IPT -A door -m recent --rcheck --seconds 5 --name knock -j stage1
$IPT -A door -p tcp --dport 1234 -m recent --set --name knock
 
$IPT -A INPUT -m --state ESTABLISHED,RELATED -j ACCEPT
$IPT -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 5 --name heaven -j ACCEPT
$IPT -A INPUT -p tcp --syn -j door

Pour plus d'informations, voir :

• Debian / Ubuntu : Configurer le Port Knocking avec Knockd et Iptables

13. Configurer l'intervalle d'expiration du journal d'inactivité

Un utilisateur peut se connecter au serveur via ssh, et vous pouvez définir un intervalle de temps d'inactivité pour éviter les sessions ssh non surveillées. Ouvrez sshd_config et assurez-vous que les valeurs suivantes sont configurées :

14. Activer une bannière d'avertissement pour les utilisateurs de ssh

Définissez une bannière d'avertissement en mettant à jour sshd_config avec la ligne suivante :

----------------------------------------------------------------------------------------------
You are accessing a XYZ Government (XYZG) Information System (IS) that is provided for authorized use only.
By using this IS (which includes any device attached to this IS), you consent to the following conditions:

+ The XYZG routinely intercepts and monitors communications on this IS for purposes including, but not limited to,
penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM),
law enforcement (LE), and counterintelligence (CI) investigations.

+ At any time, the XYZG may inspect and seize data stored on this IS.

+ Communications using, or data stored on, this IS are not private, are subject to routine monitoring,
interception, and search, and may be disclosed or used for any XYZG authorized purpose.

+ This IS includes security measures (e.g., authentication and access controls) to protect XYZG interests--not
for your personal benefit or privacy.

+ Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching
or monitoring of the content of privileged communications, or work product, related to personal representation
or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work
product are private and confidential. See User Agreement for details.
----------------------------------------------------------------------------------------------

Le texte ci-dessus est un exemple standard. Consultez votre équipe juridique pour connaître les détails de l'accord d'utilisation et des mentions légales spécifiques.

15. Désactiver les fichiers .rhosts (vérification)

Ne lisez pas les fichiers ~/.rhosts et ~/.shosts de l'utilisateur. Mettez à jour sshd_config avec les paramètres suivants :

16. Désactiver l'authentification basée sur l'hôte (vérification)

Pour désactiver l'authentification basée sur l'hôte, mettez à jour sshd_config avec l'option suivante :

17. Mettre à jour OpenSSH et les systèmes d'exploitation

Il est recommandé d'utiliser des outils tels que yum, apt-get, freebsd-update et autres pour maintenir les systèmes à jour avec les derniers correctifs de sécurité :

18. Chroot OpenSSH (verrouiller les utilisateurs dans leurs répertoires personnels)

Par défaut, les utilisateurs sont autorisés à parcourir les répertoires du serveur tels que /etc/, /bin, etc. Vous pouvez protéger ssh en utilisant un chroot basé sur le système d'exploitation ou en utilisant des outils spéciaux tels que rssh. Avec la sortie de OpenSSH 4.8p1 ou 4.9p1, vous n'avez plus à compter sur des outils tiers comme rssh ou des configurations chroot(1) compliquées pour verrouiller les utilisateurs dans leurs répertoires personnels. Voir cet article de blog sur la nouvelle directive ChrootDirectory pour verrouiller les utilisateurs sur leur répertoire d'origine.

19. Désactiver le serveur OpenSSH sur l'ordinateur client

Les stations de travail et les ordinateurs portables peuvent fonctionner sans serveur OpenSSH. Si vous ne fournissez pas les capacités de connexion à distance et de transfert de fichiers de SSH, désactivez et supprimez le serveur SSHD. Les utilisateurs de CentOS / RHEL peuvent désactiver et supprimer openssh-server avec la commande yum :

20. Conseils bonus de Mozilla

Si vous utilisez OpenSSH version 6.7 ou plus récente, essayez de suivant paramètres :

#################[ WARNING ]########################
# Do not use any setting blindly. Read sshd_config #
# man page. You must understand cryptography to    #
# tweak following settings. Otherwise use defaults #
####################################################
 
# Supported HostKey algorithms by order of preference.
HostKey /etc/ssh/ssh_host_ed25519_key
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
 
# Specifies the available KEX (Key Exchange) algorithms.
KexAlgorithms [email protected],ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha256
 
# Specifies the ciphers allowed
Ciphers [email protected],[email protected],[email protected],aes256-ctr,aes192-ctr,aes128-ctr
 
#Specifies the available MAC (message authentication code) algorithms
MACs hmac-sha2-512[email protected],hmac-sha2-256[email protected],umac-128[email protected],hmac-sha2-512,hmac-sha2-256,umac-128@openssh.com
 
# LogLevel VERBOSE logs user's key fingerprint on login. Needed to have a clear audit track of which key was using to log in.
LogLevel VERBOSE
 
# Log sftp level file access (read/write/etc.) that would not be easily logged otherwise.
Subsystem sftp  /usr/lib/ssh/sftp-server -f AUTHPRIV -l INFO

Vous pouvez obtenir la liste des codes et alogs supportés par votre serveur OpenSSH en utilisant les commandes suivantes :

Comment puis-je tester le fichier sshd_config et redémarrer/recharger mon serveur SSH ?

Pour vérifier la validité du fichier de configuration et l'intégrité des clés avant de redémarrer sshd, exécutez :

Comment auditer la configuration du serveur et du client SSH sous Linux/Unix ?

ssh-audit est un outil d'audit du serveur et du client ssh. Voir ma page sur l'installation et la configuration de ssh-audit sur votre machine Linux ou Unix.

Résumé

Si vous avez une technique ou un logiciel pratique qui n'est pas mentionné ici, merci de le partager dans les commentaires ci-dessous pour aider vos collègues lecteurs à garder leur serveur basé sur OpenSSH sécurisé. Autres suggestions :

1. Sécurité SSH renforcée avec 2FA - L'authentification multi-facteurs peut être activée avec Boîte à outils OATH ou DuoSecurity .
2. Utilisez l'authentification basée sur le trousseau de clés - keychain est un script bash spécial conçu pour rendre l'authentification basée sur les clés incroyablement pratique et flexible. Il offre divers avantages en matière de sécurité par rapport aux clés sans phrase de passe.
3. Le site officiel d'OpenSSH page d'accueil du projet .
4. Lire les pages de manuel à l'aide de la commande man/help :

   man 8 sshd
   man 1 ssh
   man 1 ssh-add
   man 1 ssh-agent
   man 5 sshd_config