Comment activer des comptes utilisateurs sous Linux à l’aide d’un script Bash automatisé ?

La gestion efficace des comptes utilisateurs est une tâche cruciale pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). Une partie importante de cette tâche consiste à activer et désactiver les comptes d’utilisateurs en fonction des besoins. Cet article présente d’un script Bash qui simplifie le processus pour activer des comptes d’utilisateurs dans les systèmes Linux. En comprenant et en utilisant ce script, les professionnels de l’informatique peuvent rationaliser la gestion des utilisateurs, renforcer la sécurité du système et assurer un fonctionnement sans heurts.

Contexte

La gestion des comptes d’utilisateurs sous Linux est une responsabilité fondamentale pour les administrateurs de systèmes. Il est essentiel de veiller à ce que seuls les utilisateurs autorisés aient accès aux ressources du système pour maintenir la sécurité et l’intégrité opérationnelle. Ce script Bash est conçu pour activer les comptes d’utilisateurs en remplaçant leur shell de connexion par /bin/bash et en déverrouillant le compte. Cette automatisation permet de gagner du temps, de réduire les erreurs humaines et de mettre en œuvre des pratiques de sécurité cohérentes dans plusieurs systèmes.

Le script :

#!/usr/bin/env bash

# Description: Enables a user account by changing its shell to /bin/bash and unlocking 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: "ReplaceMeWithUsernameToEnable"
#   Username of the user you would like to enable.
#

# 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: "ReplaceMeWithUsernameToEnable" \n'
  printf '\t%s\n' "Username of the user you would like to enable."
}

# 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_userToEnable=

# 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_userToEnable ]]; then
        _arg_userToEnable=$1
      else
        _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1' but user '$_arg_userToEnable' was already specified!" 1
      fi
      ;;
    esac
    shift
  done
}

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

if [[ -n $usernameToEnable ]]; then
  _arg_userToEnable="$usernameToEnable"
fi

# Check if the username to disable is empty and display an error if it is.
if [[ -z $_arg_userToEnable ]]; 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_userToEnable =~ ^[a-z0-9_-]+$ ]]; then
  _PRINT_HELP=no die "[Error] Invalid characters detected in '$_arg_userToEnable' usernames can only have a-z, 0-9 or -, _ characters!" 1
fi

# Search for the user in the /etc/passwd file.
passwdEntry=$(grep -w "$_arg_userToEnable" /etc/passwd)
if [[ -z $passwdEntry ]]; then
  _PRINT_HELP=no die "[Error] User '$_arg_userToEnable' does not exist." 1
fi

# Check to see if account is expired
accountExpiration=$(chage -l "$_arg_userToEnable" | grep "Account expires" | grep -v 'never' | cut -d ":" -f2 | xargs)
if [[ -n $accountExpiration ]]; then
  accountExpirationSeconds=$(date -d "$accountExpiration" +"%s")
  
  currentTime=$(date +"%s")
  # Warn if account is expired
  if [[ $accountExpirationSeconds -le $currentTime ]]; then
    echo "WARNING: The account for '$_arg_userToEnable' is currently expired as of '$accountExpiration'. You may need to set a new expiration date."
  fi
fi

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

if [[ -f /bin/bash ]]; then
  preferredShell="/bin/bash"
elif [[ -f /bin/sh ]]; then
  preferredShell="/bin/sh"
fi

# Attempt to change the shell of the user to /bin/bash to enable login capabilities.
if ! usermod "$_arg_userToEnable" -s "$preferredShell"; then
  _PRINT_HELP=no die "[Error] Failed to change the shell for '$_arg_userToEnable' to '$preferredShell'." 1
fi

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

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

 

Description détaillée

Le script Bash fourni accomplit sa tâche en plusieurs étapes bien définies. Décortiquons chaque partie du script pour en comprendre la fonctionnalité :

1. Texte d’aide et fonctions de gestion des erreurs:

• Le script commence par définir des fonctions permettant d’afficher un texte d’aide (print_help) et de gérer les erreurs (die). Ces fonctions garantissent que l’utilisateur est informé de l’utilisation correcte du script et qu’il peut résoudre les problèmes de manière efficace.

2. Analyse des paramètres:

• La fonction parse_commandline traite les arguments de la ligne de commande du script. Il vérifie la présence du drapeau –help, des arguments inattendus et s’assure qu’un seul nom d’utilisateur est fourni.

3. Validation du nom d’utilisateur:

• Le script valide le nom d’utilisateur fourni pour s’assurer qu’il ne contient que des lettres minuscules, des chiffres, des traits d’union et des traits de soulignement. Cette étape permet d’éviter les problèmes de sécurité potentiels liés à des caractères non valides.

4. Contrôle d’existence de l’utilisateur:

• Le script vérifie si l’utilisateur existe dans le fichier /etc/passwd. Si l’utilisateur n’existe pas, le programme se termine par un message d’erreur.

5. Expiration du compte Vérifier:

• Le script utilise la commande chage pour déterminer si le compte a expiré. S’il a expiré, il avertit l’utilisateur, tout en continuant à essayer d’activer le compte.

6. Shell de connexion et vérification de l’état du compte:

• Il vérifie si le shell de connexion de l’utilisateur est défini sur nologin et si le compte est déjà déverrouillé. Si l’utilisateur est déjà activé, l’opération se termine par une erreur.

7. Sélection de la coquille:

• Le script vérifie l’existence de /bin/bash et /bin/sh, en préférant /bin/bash s’il est disponible.

8. Changement de shell et déverrouillage du compte:

• Le script tente de remplacer le shell de connexion de l’utilisateur par le shell préféré et de déverrouiller le compte à l’aide de la commande usermod.

9. Vérification finale:

• Il vérifie que l’utilisateur a été activé avec succès en s’assurant que nologin n’est plus défini. En cas de succès, il imprime un message de confirmation.

Cas d’utilisation potentiels

Imaginez un scénario dans lequel un professionnel des technologies de l’information gère une grande équipe avec des changements fréquents de personnel. Un employé qui revient d’un congé prolongé doit réactiver son compte. Grâce à ce script, le professionnel de l’informatique peut rapidement activer le compte sans avoir à naviguer manuellement entre plusieurs commandes, ce qui garantit un processus à la fois rapide et exempt d’erreurs.

Comparaisons

Ce script offre une approche rationalisée et automatisée de l’activation des comptes d’utilisateurs par rapport aux méthodes manuelles. L’activation manuelle d’un utilisateur implique plusieurs étapes : modification du fichier /etc/passwd, changement de shell et déverrouillage du compte. Chaque étape est sujette à une erreur humaine. En revanche, ce script regroupe toutes ces étapes en un processus unique et reproductible, ce qui améliore la fiabilité et l’efficacité.

FAQ

1) Que se passe-t-il si le nom d’utilisateur n’est pas valide ?

Le script se termine par un message d’erreur indiquant que le nom d’utilisateur contient des caractères non valides.

2) Ce script peut-il être utilisé pour activer plusieurs utilisateurs à la fois ?

Non, le script est conçu pour n’autoriser qu’un seul utilisateur à la fois afin de garantir l’exactitude et la sécurité.

3) Que faire si l’interpréteur de commandes préféré /bin/bash n’est pas disponible ?

Le script revient à l’utilisation de /bin/sh si /bin/bash n’est pas trouvé.

4) Le script traite-t-il toutes les erreurs liées au compte ?

Le script gère les erreurs courantes telles que les noms d’utilisateur invalides, les utilisateurs inexistants et les comptes déjà activés.

Implications

L’activation sécurisée des comptes d’utilisateurs est essentielle au maintien de l’intégrité du système. Les scripts automatisés de ce type réduisent le risque d’erreur humaine et garantissent que les comptes sont activés correctement et rapidement. Cela contribue à la sécurité globale du système et à l’efficacité opérationnelle, qui sont primordiales dans tout environnement informatique.

Recommandations

Lors de l’utilisation de ce script, il convient de respecter les bonnes pratiques suivantes :

• Test dans un environnement contrôlé: Avant de déployer le script dans un environnement de production, testez-le dans un environnement d’essai pour vous assurer qu’il se comporte comme prévu.

• Audits réguliers: Examinez périodiquement les comptes d’utilisateurs et les fonctionnalités du script pour s’assurer qu’ils sont conformes aux politiques de sécurité.

• Documentation : Conservez une documentation détaillée de toutes les personnalisations apportées au script afin de faciliter la maintenance future.

Conclusion

Une gestion efficace des comptes utilisateurs est essentielle pour maintenir un environnement informatique sûr et efficace. Ce script Bash offre une solution fiable et automatisée pour activer les comptes d’utilisateurs sous Linux. Pour les organisations qui cherchent à rationaliser davantage leurs opérations informatiques, des outils tels que NinjaOne peuvent fournir des solutions de gestion complètes, améliorant l’efficacité et la sécurité dans tous les domaines.