Guide complet pour désactiver des comptes utilisateurs sous Linux pour les professionnels de l’informatique

La gestion des comptes d’utilisateurs est un aspect crucial de l’administration des systèmes, en particulier lorsqu’il s’agit de garantir la sécurité et l’intégrité d’un environnement Linux. Désactiver des comptes utilisateurs qui ne sont plus utilisés ou qui sont potentiellement compromis est une pratique courante parmi les professionnels de l’informatique et les fournisseurs de services gérés (MSP).

Cet article présente un script complet conçu pour désactiver les comptes d’utilisateurs sous Linux, en fournissant une compréhension approfondie de sa fonctionnalité, des cas d’utilisation et des bonnes pratiques.

Comprendre l’importance de la gestion des comptes d’utilisateurs

Dans toute infrastructure informatique, la gestion des comptes utilisateurs est primordiale pour maintenir la sécurité et l’efficacité opérationnelle. L’accès non autorisé ou l’utilisation abusive des comptes d’utilisateurs peut entraîner des violations de données, la perte d’informations sensibles et une éventuelle indisponibilité du système. Par conséquent, la désactivation des comptes d’utilisateurs inactifs ou compromis est une mesure proactive pour protéger le système.

Contexte du script

Le script que nous examinons est conçu pour désactiver un compte d’utilisateur spécifié en remplaçant son shell de connexion par /sbin/nologin et en verrouillant le compte. Ce processus empêche l’utilisateur de se connecter tout en préservant le compte en vue d’une éventuelle réactivation ou à des fins d’audit. Cette approche est préférée à la suppression pure et simple, car elle permet de conserver intact l’historique du compte et les fichiers associés.

Le script :

#!/usr/bin/env bash

# Description: Disables a user account by changing its shell to /sbin/nologin and locking the account.
#
# Release Notes: Initial Release
# 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).
#
# Below are all the valid parameters for this script.
#
# Preset Parameter: "ReplaceMeWithUsernameToDisable"
#   Username of the user you would like to disable.
#

# Help text function for when invalid input is encountered
print_help() {
  printf '\n### Below are all the valid parameters for this script. ###\n'
  printf '\nPreset Parameter: "ReplaceMeWithUsernameToDisable" \n'
  printf '\t%s\n' "Username of the user you would like to disable."
}

# Determines whether or not help text is nessessary and routes the output to stderr
die() {
  local _ret="${2:-1}"
  echo "$1" >&2
  test "${_PRINT_HELP:-no}" = yes && print_help >&2
  exit "${_ret}"
}

_arg_userToDisable=

# Grabbing the parameters and parsing through them.
parse_commandline() {
  while test $# -gt 0; do
    _key="$1"
    case "$_key" in
    --help | -h)
      _PRINT_HELP=yes die 0
      ;;
    --*)
      _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
      ;;
    *)
      if [[ -z $_arg_userToDisable ]]; then
        _arg_userToDisable=$1
      else
        _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1' but user '$_arg_userToDisable' was already specified!" 1
      fi
      ;;
    esac
    shift
  done
}

# Parse the command-line arguments passed to the script.
parse_commandline "$@"

if [[ -n $usernameToDisable ]]; then
  _arg_userToDisable="$usernameToDisable"
fi

# Check if the username to disable is empty and display an error if it is.
if [[ -z $_arg_userToDisable ]]; then
  _PRINT_HELP=yes die "[Error] The username of the user you would like to disable is required!'" 1
fi

# Validate the username to ensure it only contains lowercase letters, digits, hyphens, and underscores.
if [[ ! $_arg_userToDisable =~ ^[a-z0-9_-]+$ ]]; then
  _PRINT_HELP=no die "[Error] Invalid characters detected in '$_arg_userToDisable' usernames can only have a-z, 0-9 or -, _ characters!" 1
fi

# Search for the user in the /etc/passwd file and ensure the user account is not already set to 'nologin'.
passwdEntry=$(grep -w "$_arg_userToDisable" /etc/passwd)
if [[ -z $passwdEntry ]]; then
  _PRINT_HELP=no die "[Error] User '$_arg_userToDisable' does not exist." 1
fi

unlockedaccount=$(passwd -S "$_arg_userToDisable" | cut -f2 -d " " | grep -v "L")
nologin=$(grep -w "$_arg_userToDisable" /etc/passwd | cut -d ":" -f7 | grep "nologin")
if [[ -z $unlockedaccount && -n $nologin ]]; then
  _PRINT_HELP=no die "[Error] User '$_arg_userToDisable' is already disabled. $nologin" 1
fi

# Check if the 'sudo' command is available on the system.
sudoAvailable=$(command -v sudo)

# If 'sudo' is available, check if the specified user has sudo privileges and is not explicitly forbidden from using sudo.
if [[ -n $sudoAvailable ]]; then
  sudoAccess=$(sudo -l -U "$_arg_userToDisable" | grep -v "is not allowed to run sudo")
fi

# Initialize a flag to check for the availability of another administrative user.
anotherAdminAvaliable=false

# If the user to disable is 'root' or if they have sudo access, proceed to check for other admin users.
if [[ "$_arg_userToDisable" == "root" || -n $sudoAccess ]]; then
 # Fetch all user accounts with UID >= 1000 (typically regular users) and exclude the specified user and 'nobody'.
  allAccounts=$(cut -d ":" -f1,3 /etc/passwd | grep -v -w "$_arg_userToDisable" | grep -v "nobody" | awk -F ':' '$2 >= 1000 {print $1}')

  # If the user to disable is not 'root', add 'root' to the list of all accounts if it is enabled and not set to 'nologin'.
  if [[ ! "$_arg_userToDisable" == "root" ]]; then
    enabled=$(grep -w "root" /etc/passwd | grep -v "nologin")
    if [[ -n $enabled ]]; then
      allAccounts=$(echo "$allAccounts"; echo "root")
    fi
  fi

  # Iterate over each account to check if there are other admin users available.
  for account in $allAccounts; do
    # Skip checking accounts if 'sudo' is not available.
    if [[ -z $sudoAvailable ]]; then
      continue
    fi

    # Check if the current account has sudo access.
    sudoAccess=$(sudo -l -U "$account" | grep -v "is not allowed to run sudo")
    if [[ -z $sudoAccess ]]; then
      continue
    fi

    # Check if the current account is enabled (i.e., not set to 'nologin').
    accountEnabled=$(grep -w "$account" /etc/passwd | grep -v "nologin")
    if [[ -z $accountEnabled ]]; then
      continue
    fi

    # If an admin account is available and enabled, set the flag to true.
    anotherAdminAvaliable="true"
  done

  # If no other admin users are available, output an error and suggest creating another admin account.
  if [[ $anotherAdminAvaliable == "false" ]]; then
    _PRINT_HELP=no die "[Error] No other admins available. Please create another account to administer the system." 1
  fi
fi

# Attempt to change the shell of the user to /sbin/nologin to disable login capabilities.
if ! usermod "$_arg_userToDisable" -s /sbin/nologin; then
  _PRINT_HELP=no die "[Error] Failed to change the shell for '$_arg_userToDisable' to /sbin/nologin." 1
fi

# Attempt to lock the user account using usermod.
if ! usermod -L "$_arg_userToDisable"; then
  _PRINT_HELP=no die "[Error] Failed to lock '$_arg_userToDisable' using usermod." 1
fi

# Check if the user has been successfully disabled by confirming 'nologin' is set.
disabledUser=$(grep -w "$_arg_userToDisable" /etc/passwd | grep "nologin")
if [[ -n $disabledUser ]]; then
  echo "Successfully disabled '$_arg_userToDisable'."
else
  _PRINT_HELP=no die "[Error] Failed to disable '$_arg_userToDisable'." 1
fi

 

Description détaillée

Configuration initiale et analyse des paramètres

Le script commence par définir une fonction de texte d’aide (print_help) et une fonction die (die) pour gérer les erreurs et afficher les messages pertinents. La fonction parse_commandline traite les arguments de la ligne de commande pour identifier le nom d’utilisateur du compte à désactiver.

Validation du compte utilisateur

Le script vérifie ensuite si le nom d’utilisateur spécifié est valide et s’il existe dans le système. Il s’assure que le nom d’utilisateur ne contient que des caractères autorisés (lettres minuscules, chiffres, tirets et traits de soulignement) et vérifie son existence dans le fichier /etc/passwd.

S’assurer qu’il n’y a pas de conflit avec les comptes d’administration

Le script vérifie en outre si l’utilisateur à désactiver dispose de privilèges administratifs. Il vérifie s’il existe d’autres comptes d’administration disponibles afin d’éviter le verrouillage de l’accès administratif essentiel.

Désactivation du compte utilisateur

Enfin, le script désactive le compte utilisateur en remplaçant le shell par /sbin/nologin et en verrouillant le compte. Il vérifie le succès de ces opérations et fournit un retour d’information.

Cas d’utilisation potentiels

Prenons l’exemple d’un professionnel de l’informatique qui doit désactiver le compte d’un employé qui a quitté l’entreprise. Le script fournit une méthode rationnelle et efficace pour s’assurer que le compte est désactivé sans le supprimer. Cela permet à l’équipe informatique de conserver les données de l’utilisateur et l’historique de son compte à des fins de conformité et d’audit.

Comparaisons avec d’autres méthodes

L’approche traditionnelle pour désactiver un compte d’utilisateur peut impliquer de modifier manuellement le fichier /etc/passwd ou d’exécuter plusieurs commandes. Ce script automatise le processus, réduisant le risque d’erreur humaine et garantissant la cohérence entre les différents systèmes.

FAQ

Q : Ce script peut-il supprimer un compte d’utilisateur ?

R : Non, le script ne fait que désactiver le compte en modifiant le shell et en le verrouillant. La suppression d’un compte nécessiterait des commandes supplémentaires.

Q : Est-il possible de désactiver le compte root en toute sécurité ?

R : La désactivation du compte root peut rendre le système ingérable. Le script inclut des vérifications pour s’assurer qu’un autre compte administrateur est disponible avant de poursuivre.

Q : Que se passe-t-il si le compte d’utilisateur est déjà désactivé ?

R : Le script vérifie l’état du compte et notifie si le compte est déjà désactivé, ce qui évite les opérations redondantes.

Implications pour la sécurité informatique

La désactivation des comptes d’utilisateurs inactifs ou compromis est une mesure de sécurité essentielle. Il réduit la surface d’attaque et empêche les accès non autorisés, améliorant ainsi le niveau de sécurité global de l’organisation.

Recommandations

Lorsque vous utilisez ce script, assurez-vous que

• Vous disposez d’un autre compte administratif.

• Révisez et mettez à jour régulièrement vos politiques de gestion des comptes d’utilisateurs.

• Testez le script dans un environnement de non-production avant de le déployer dans un environnement réel.

Conclusion

La gestion des comptes d’utilisateurs est un aspect fondamental de l’administration des systèmes. Ce script simplifie le processus de désactivation des comptes d’utilisateurs sous Linux, en offrant une solution robuste et automatisée. Des outils tels que NinjaOne peuvent rationaliser davantage les opérations informatiques, en fournissant des capacités de gestion et de surveillance complètes pour s’assurer que vos systèmes restent sécurisés et efficaces.

En suivant les bonnes pratiques et en utilisant des scripts automatisés, les professionnels de l’informatique peuvent maintenir un environnement Linux sécurisé et bien géré, protégeant ainsi leur infrastructure contre les menaces potentielles et garantissant une continuité opérationnelle sans heurts.