Désactiver PermitEmptyPasswords à l’aide d’un script Bash pour sécuriser l’accès SSH 

Garantir un accès sécurisé aux serveurs est une priorité absolue pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). Un aspect important de la sécurité des serveurs est la gestion des configurations SSH afin d’empêcher tout accès non autorisé. Une mesure de sécurité essentielle consiste à désactiver l’option PermitEmptyPasswords dans OpenSSH, qui empêche les utilisateurs de se connecter avec un mot de passe vide. Cet article présente un script Bash conçu pour appliquer cette configuration, garantissant ainsi une sécurité accrue pour les systèmes Linux.

Contexte

OpenSSH est un protocole largement utilisé pour la gestion sécurisée de serveurs à distance. Par défaut, l’option PermitEmptyPasswords est définie sur “no”, mais il est essentiel de vérifier et d’appliquer ce paramètre afin de limiter les risques associés à des configurations erronées ou négligées. Les professionnels de l’informatique qui gèrent plusieurs systèmes peuvent négliger ce détail, ce qui rend les serveurs vulnérables. Ce script fournit une solution automatisée, garantissant la conformité avec les meilleures pratiques en désactivant explicitement les connexions par mot de passe vide.

Pour les MSP et les administrateurs gérant de nombreux serveurs, ce script simplifie le durcissement de SSH, offrant un moyen rapide et fiable de renforcer la sécurité sans intervention manuelle.

Le script :

#!/usr/bin/env bash

# Description: Explicitly disables PermitEmptyPasswords in OpenSSH.
# By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
# Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
# Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
# Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
# Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
# Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
# Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
# EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
# PermitEmptyPasswords defaults to no when not specified in the sshd_config file.
# This script will ensure that it is set to no to prevent SSH from accepting empty passwords.
#
# Links: https://man.openbsd.org/sshd_config#PermitEmptyPasswords
#
# Release Notes: Initial Release

# Logs an error message and exits with the specified exit code
die() {
    local _ret="${2:-1}"
    echo "$1" >&2
    exit "${_ret}"
}

# Check that we are running as root
if [[ $EUID -ne 0 ]]; then
    die "[Error] This script must be run as root." 1
fi

_should_reload="false"

# Check if the sshd_config file exists
if [[ -f /etc/ssh/sshd_config ]]; then
    # Check if the PermitEmptyPasswords option is already set to no
    if grep -q "^PermitEmptyPasswords no" /etc/ssh/sshd_config; then
        echo "[Info] PermitEmptyPasswords is already set to no."
        _should_reload="false"
    elif grep -q "^PermitEmptyPasswords yes" /etc/ssh/sshd_config; then
        # First check if the option is not commented out and set to yes
        # Then set the PermitEmptyPasswords option to no
        sed -i 's/^PermitEmptyPasswords.*/PermitEmptyPasswords no/' /etc/ssh/sshd_config
        echo "[Info] PermitEmptyPasswords set to no."
        _should_reload="true"
    elif grep -q "^#PermitEmptyPasswords" /etc/ssh/sshd_config; then
        # First check if the option is commented out
        # Then set the PermitEmptyPasswords option to no
        sed -i 's/^#PermitEmptyPasswords.*/PermitEmptyPasswords no/' /etc/ssh/sshd_config
        echo "[Info] PermitEmptyPasswords set to no, as it was commented out."
        _should_reload="true"
    else
        # Append the PermitEmptyPasswords option to the end of the sshd_config file
        # If the past checks have not found the option, appending it will ensure that it is set to no
        echo "PermitEmptyPasswords no" >>/etc/ssh/sshd_config
        echo "[Info] PermitEmptyPasswords set to no at the end of the sshd_config file."
        _should_reload="true"
    fi

    # Check that this system is running systemd-based
    _type=$(
        # Get the type of init system
        file /sbin/init 2>/dev/null | awk -F/ '{print $NF}' 2>/dev/null
    )
    if [[ "${_type}" == "systemd" ]] && [ "$(command -v systemctl)" ]; then
        echo "[Info] Reloading ${sshd_service} service..."
        # Find the sshd service
        sshd_service=$(
            # Get the ssh service, if two are found use the first one. Likely the first one is a symlink to the actual service file.
            systemctl list-unit-files | grep -E "^(sshd|ssh|openssh-server)\.service" | awk -F' ' '{print $1}' | head -n 1
        )
        if [[ -z "${sshd_service}" ]]; then
            die "[Error] sshd service is not available. Please install it and try again." 1
        fi
        # Check that ssh service is enabled
        if systemctl is-enabled "${sshd_service}" >/dev/null; then
            echo "[Info] ${sshd_service} is enabled."
        else
            die "[Info] ${sshd_service} is not enabled. When enabled and started, PermitEmptyPasswords will be set to no." 0
        fi
        # Check that ssh service is running
        if systemctl is-active "${sshd_service}" >/dev/null; then
            echo "[Info] ${sshd_service} is running."
            if [[ "${_should_reload}" == "true" ]]; then
                # Reload sshd.service
                if systemctl reload "${sshd_service}"; then
                    echo "[Info] sshd service configuration reloaded."
                else
                    die "[Error] Failed to reload ${sshd_service}. Please try again." 1
                fi
            else
                echo "[Info] sshd service configuration will not be reloaded as there is no need to do so."
            fi
        else
            echo "[Info] ${sshd_service} is not running."
        fi
    else
        echo "[Info] Restarting sshd service..."
        # Check that the service command is available
        if ! [ "$(command -v service)" ]; then
            die "[Error] The service command is not available. Is this an initd type system (e.g. SysV)? Please try again." 1
        fi
        # Find the sshd service
        sshd_service=$(
            # Get the list of services
            service --status-all | awk -F' ' '{print $NF}' | grep sshd
        )
        if [[ -z "${sshd_service}" ]]; then
            die "[Error] sshd service is not available. Please install it and try again." 1
        fi
        if [[ "${_should_reload}" == "true" ]]; then
            # Restart sshd service
            if service "${sshd_service}" restart; then
                echo "[Info] sshd service restarted."
            else
                die "[Error] Failed to restart sshd service. Please try again." 1
            fi
        else
            echo "[Info] sshd service configuration will not be restarted as there is no need to do so."
        fi
    fi
else
    die "[Error] The sshd_config file does not exist." 1
fi

 

Description détaillée

Ce script Bash automatise le processus consistant à définir explicitement PermitEmptyPasswords sur “no” dans le fichier de configuration SSH (/etc/ssh/sshd_config). Vous trouverez ci-dessous une description étape par étape du fonctionnement du script :

1. Vérifier les privilèges root

Le script commence par vérifier s’il est exécuté en tant qu’utilisateur root, car la modification des configurations SSH nécessite des autorisations élevées. Si ce n’est pas le cas, il se termine par une erreur.

bash

Copiez le code

if [[ $EUID -ne 0 ]]; then
die “[Error] This script must be run as root.” 1
fi

2. Identifier le fichier de configuration

Le script vérifie l’existence du fichier /etc/ssh/sshd_config. Si ce fichier est manquant, le script se termine par une erreur, car il ne peut pas continuer sans le fichier de configuration SSH.

3. Modifiez le paramètre PermitEmptyPasswords

Le script inspecte le fichier à la recherche de la directive PermitEmptyPasswords :

• Si la directive est définie sur “no”, aucune modification n’est apportée.
• Si la valeur est “yes”, elle est remplacée par “no”
• S’il est commenté, le script le décommente et lui attribue la valeur “no”
• Si la directive est entièrement absente, il ajoute “PermitEmptyPasswords no” au fichier.

4. Recharger le service SSH

Le script détermine le système init du système (systemd ou init.d) pour recharger ou redémarrer le service SSH de manière appropriée. Il garantit que les modifications sont appliquées sans perturber les sessions SSH en cours.

5. Gestion des erreurs

Une gestion complète des erreurs garantit que le script se termine de manière élégante s’il rencontre des problèmes tels que des commandes manquantes, des services désactivés ou des systèmes d’initialisation non pris en charge.

Cas d’utilisation potentiels

Scénario hypothétique

Un administrateur informatique gérant un parc de serveurs remarque qu’un serveur autorise l’accès SSH avec des mots de passe vides. L’inspection et la modification manuelles des fichiers de configuration sur tous les serveurs prendraient beaucoup de temps. En déployant ce script via des outils d’automatisation comme Ansible ou directement via SSH, l’administrateur s’assure que tous les serveurs appliquent le paramètre PermitEmptyPasswords no de manière cohérente et efficace.

Comparaisons

Configuration manuelle

La modification manuelle du fichier sshd_config et le redémarrage du service SSH sont des opérations simples, mais sources d’erreurs et inefficaces dans le cas de serveurs multiples.

Outils de configuration centralisés

Les outils de gestion de la configuration tels que Puppet ou Chef permettent d’appliquer les paramètres SSH à l’ensemble de l’infrastructure. Toutefois, ces outils nécessitent une configuration et sont plus complexes que ce script léger pour les déploiements à petite échelle.

Le script propose une solution intermédiaire simple, ciblée et efficace pour une implémentation immédiate.

FAQ

1. Que se passe-t-il si PermitEmptyPasswords n’est pas spécifié dans le fichier de configuration ?
   Le script ajoute PermitEmptyPasswords no au fichier, ce qui désactive explicitement les connexions avec des mots de passe vides.
2. Ce script peut-il interrompre l’accès SSH ?
   Non, il ne modifie qu’une directive spécifique et recharge/redémarre le service SSH sans interrompre les sessions actives.
3. Ce script est-il compatible avec toutes les distributions Linux ?
   Il est conçu pour les distributions utilisant OpenSSH et prend en charge les systèmes systemd et init.d.
4. Dois-je redémarrer manuellement le service SSH ?
   Non, le script gère le rechargement ou le redémarrage des services si nécessaire.

Implications

En appliquant la règle PermitEmptyPasswords no, ce script atténue un risque de sécurité critique. Des paramètres SSH mal configurés peuvent exposer les serveurs à des attaques par force brute et à des accès non autorisés. Ce script garantit le respect des bonnes pratiques en matière de sécurité, en réduisant la surface d’attaque et en protégeant les systèmes sensibles.

Recommandations

• Test avant déploiement : exécutez le script dans un environnement de test pour vérifier son comportement.
• Automatiser l’implémentation : utilisez des outils comme Ansible pour déployer ce script sur plusieurs serveurs.
• Surveiller les journaux : vérifiez les journaux SSH pour vous assurer que les changements de configuration sont effectifs.
• Documenter les modifications : conservez les enregistrements des configurations appliquées à des fins d’audit.

Conclusion

Le maintien d’un environnement SSH sécurisé est vital pour les opérations informatiques. Les scripts comme celui-ci simplifient le processus d’application des mesures de sécurité essentielles, garantissent la conformité et protègent les systèmes contre les accès non autorisés. Pour les professionnels de l’informatique qui gèrent de grandes infrastructures, l’utilisation d’outils d’automatisation tels que NinjaOne améliore l’efficacité opérationnelle, en offrant des solutions de gestion et de surveillance centralisées adaptées à leurs besoins.