Guide complet de script : Créer un nouvel utilisateur administrateur sous Linux

Points à retenir

• Automatise la création d’utilisateurs administratifs : Rationalise le processus d’ajout de nouveaux utilisateurs administrateurs dans les environnements Linux.
• Améliore l’efficacité et la précision : Réduit les efforts manuels et minimise le risque d’erreur humaine.
• Flexibilité du script : Adaptable à différents besoins, en prenant en charge différentes options d’utilisateurs, de mots de passe et de groupes.
• Axé sur la sécurité : Incorpore le cryptage des mots de passe et requiert les privilèges de l’administrateur, ce qui donne la priorité à la sécurité.
• Utilisation polyvalente : Convient aussi bien aux particuliers qu’aux MSP qui gèrent plusieurs systèmes Linux.
• Comparaison avec les méthodes traditionnelles : Offre une solution plus cohérente et plus évolutive que les commandes manuelles ou les outils GUI.
• Questions fréquemment posées : Clarifie les questions de sécurité, d’opérations en vrac et de compatibilité.
• Implications en matière de sécurité : Souligne l’importance d’une bonne gestion des privilèges et d’un audit de l’utilisation des scripts.
• Recommandations de bonnes pratiques : Il est conseillé de procéder à des tests, à des enregistrements et à des examens réguliers des comptes.
• Intégration de NinjaOne : Souligne la manière dont ces scripts complètent des plateformes de gestion informatique plus larges telles que NinjaOne.

L’administration efficace des systèmes Linux nécessite souvent la création et la gestion de comptes d’utilisateurs, en particulier ceux qui disposent de privilèges administratifs. Il est essentiel pour les administrateurs de systèmes et les professionnels de l’informatique de comprendre les nuances de ce processus. Le script présenté aujourd’hui répond à ce besoin en fournissant un moyen efficace d’ajouter de nouveaux utilisateurs administrateurs dans les environnements Linux.

Contexte

Dans le monde de l’informatique, la gestion des comptes utilisateurs est une tâche fondamentale. Ce script est particulièrement utile pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui gèrent fréquemment plusieurs serveurs ou postes de travail Linux. L’automatisation de la création d’utilisateurs administratifs permet non seulement de gagner du temps, mais aussi de réduire le risque d’erreur humaine. Son importance ne peut être sous-estimée dans les scénarios où une gestion rapide et sûre des utilisateurs est essentielle.

Le script :

#!/usr/bin/env bash
#
# Description: Create a new admin user for Linux, by adding the user to the sudo group.
# 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).

# Usage: [-u|--user <arg>] [-p|--pass <arg>] [-g|--group <arg>] [-d|--disable <arg>] [-h|--help]
# -u, --user: User Name for new user account. (no default)
# -p, --pass: Password for new user account. (no default)
# -g, --group: Name of group to add the new user account to. (default 'sudo')
# -d, --disable: Date to disable account. (no default)
# -h, --help: Prints help

# # When called, the process ends.
# Args:
# 	$1: The exit message (print to stderr)
# 	$2: The exit code (default is 1)
# if env var _PRINT_HELP is set to 'yes', the usage is print to stderr (prior to $1)
# Example:
# 	test -f "$_arg_infile" || _PRINT_HELP=yes die "Can't continue, have to supply file as an argument, got '$_arg_infile'" 4
die() {
    local _ret="${2:-1}"
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    echo "$1" >&2
    exit "${_ret}"
}

# Function that evaluates whether a value passed to it begins by a character
# that is a short option of an argument the script knows about.
# This is required in order to support getopts-like short options grouping.
begins_with_short_option() {
    local first_option all_short_options='uph'
    first_option="${1:0:1}"
    test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0
}
_arg_user=
_arg_pass=
_arg_group="sudo"
_arg_disable=

if [[ -n "${username}" ]]; then
    _arg_user=$username
fi
if [[ -n "${password}" ]]; then
    _arg_pass=$password
fi
if [[ -n "${group}" ]] && [[ "${group}" != "null" ]]; then
    _arg_group=$group
fi
if [[ -n "${disableAfterDate}" ]] && [[ "${disableAfterDate}" != "null" ]]; then
    _arg_disable=$(date -d "$disableAfterDate" +'%Y-%m-%d')
fi

# Function that prints general usage of the script.
# This is useful if users asks for it, or if there is an argument parsing error (unexpected / spurious arguments)
# and it makes sense to remind the user how the script is supposed to be called.
print_help() {
    printf '%s\n' "Create a new admin user."
    printf 'Usage: %s [-u|--user <arg>] [-p|--pass <arg>] [-g|--group <arg>] [-e|--enable <arg>] [-d|--disable <arg>] [-h|--help]\n' "$0"
    printf '\t%s\n' "-u, --user: User Name for new user account. (no default)"
    printf '\t%s\n' "-p, --pass: Password for new user account. (no default)"
    printf '\t%s\n' "-g, --group: Name of group to add the new user account to. (default 'sudo')"
    printf '\t%s\n' "-d, --disable: Date to disable account. (no default)"
    printf '\t%s\n' "-h, --help: Prints help"
}

# The parsing of the command-line
parse_commandline() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        # We support whitespace as a delimiter between option argument and its value.
        # Therefore, we expect the --user or -u value.
        # so we watch for --user and -u.
        # Since we know that we got the long or short option,
        # we just reach out for the next argument to get the value.
        -u | --user)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_user="$2"
            shift
            ;;
        # We support the = as a delimiter between option argument and its value.
        # Therefore, we expect --user=value, so we watch for --user=*
        # For whatever we get, we strip '--user=' using the ${var##--user=} notation
        # to get the argument value
        --user=*)
            _arg_user="${_key##--user=}"
            ;;
        # We support getopts-style short arguments grouping,
        # so as -u accepts value, we allow it to be appended to it, so we watch for -u*
        # and we strip the leading -u from the argument string using the ${var##-u} notation.
        -u*)
            _arg_user="${_key##-u}"
            ;;
        # See the comment of option '--user' to see what's going on here - principle is the same.
        -p | --pass)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_pass="$2"
            shift
            ;;
        # See the comment of option '--user=' to see what's going on here - principle is the same.
        --pass=*)
            _arg_pass="${_key##--pass=}"
            ;;
        # See the comment of option '-u' to see what's going on here - principle is the same.
        -p*)
            _arg_pass="${_key##-p}"
            ;;
        # See the comment of option '--user' to see what's going on here - principle is the same.
        -g | --group)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_group="$2"
            shift
            ;;
        # See the comment of option '--user=' to see what's going on here - principle is the same.
        --group=*)
            _arg_group="${_key##--group=}"
            ;;
        # See the comment of option '-u' to see what's going on here - principle is the same.
        -g*)
            _arg_group="${_key##-g}"
            ;;
        # See the comment of option '--user' to see what's going on here - principle is the same.
        -d | --disable)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_disable="$2"
            shift
            ;;
        # See the comment of option '--user=' to see what's going on here - principle is the same.
        --disable=*)
            _arg_disable="${_key##--disable=}"
            ;;
        # See the comment of option '-u' to see what's going on here - principle is the same.
        -d*)
            _arg_disable="${_key##-d}"
            ;;
        # The help argument doesn't accept a value,
        # we expect the --help or -h, so we watch for them.
        -h | --help)
            print_help
            exit 0
            ;;
        # We support getopts-style short arguments clustering,
        # so as -h doesn't accept value, other short options may be appended to it, so we watch for -h*.
        # After stripping the leading -h from the argument, we have to make sure
        # that the first character that follows corresponds to a short option.
        -h*)
            print_help
            exit 0
            ;;
        *)
            _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

parse_commandline "$@"

if [[ -z "${_arg_user}" ]]; then
    die "FATAL ERROR: User Name is required. '$_arg_user'" 1
fi

if [[ -z "${_arg_pass}" ]]; then
    die "FATAL ERROR: Password is required. '$_arg_pass'" 1
fi

if [ "$(id -u)" -eq 0 ]; then
    if grep -E "^$_arg_user" /etc/passwd >/dev/null; then
        # User already exists, add them to the group
        echo "$_arg_user exists!"
        if usermod -aG "$_arg_group" "$_arg_user"; then
            echo "User($_arg_user) has been added to $_arg_group group!"
        else
            echo "Failed to add a user to $_arg_group group!"
            exit 1
        fi
    else
        pass=$(perl -e 'print crypt($ARGV[0], "password")' "$_arg_pass")
        if useradd -m -p "$pass" "$_arg_user"; then
            echo "User($_arg_user) has been added to system!"
        else
            echo "Failed to add a user!"
            exit 1
        fi
        if usermod -aG "$_arg_group" "$_arg_user"; then
            echo "User($_arg_user) has been added to $_arg_group group!"
        else
            echo "Failed to add a user to $_arg_group group!"
            exit 1
        fi
    fi
    if [[ -n "${_arg_disable}" ]]; then
        # Expire the user after date
        usermod -e "$_arg_disable" "$_arg_user"
    fi

else
    echo "Only root may add a user to the system."
    exit 2
fi

 

Description détaillée

Fonctionnalité du script :

• Configuration de l’environnement : Le script commence par une ligne shebang(#!/usr/bin/env bash), qui configure l’environnement pour utiliser Bash comme langage de script.
• Description et utilisation : Il comprend des commentaires expliquant son objectif : créer un nouvel utilisateur administrateur en l’ajoutant à un groupe, généralement “sudo”.
• Définitions des fonctions :
  • die(): Gère les scénarios de sortie, en affichant des messages d’erreur si nécessaire.
  • begins_with_short_option() : Aide à l’analyse des options de la ligne de commande. \
  • print_help() : Affiche les instructions d’utilisation.
• Initialisation des variables : Les variables telles que _arg_user, _arg_pass, _arg_group et _arg_disable sont initialisées.
• Analyse des arguments de la ligne de commande : La fonction parse_commandline() itère sur les arguments pour définir l’utilisateur, le mot de passe, le groupe et la date de désactivation.
• Logique de création de l’utilisateur :
  • Vérifie si l’utilisateur existe.
  • Si ce n’est pas le cas, il crée un nouvel utilisateur et l’ajoute au groupe spécifié.
  • La date de désactivation du compte d’utilisateur est facultative.
• Vérification des privilèges de la racine : Assure que le script est exécuté par un utilisateur disposant des privilèges de l’administrateur (root), une étape nécessaire pour créer et modifier des comptes d’utilisateurs.

Cas d’utilisation potentiels

Prenons l’exemple d’un prestataire de services de gestion qui gère un parc de serveurs Linux pour le compte d’un client. Ils reçoivent une demande d’intégration rapide d’une nouvelle équipe de développeurs ayant besoin d’un accès administrateur. Grâce à ce script, le MSP peut créer efficacement des comptes d’administration individuels, garantissant à chaque membre de l’équipe un accès approprié sans intervention manuelle, ce qui permet de gagner du temps et de minimiser les erreurs.

Comparaisons

Traditionnellement, la création d’un nouvel utilisateur administrateur sous Linux implique plusieurs commandes manuelles(useradd, passwd, usermod). Ce script automatise ces étapes en un seul processus cohérent. Contrairement aux outils de gestion des utilisateurs basés sur une interface graphique, ce script peut être intégré dans des flux de travail d’automatisation plus importants, ce qui le rend plus souple et plus évolutif.

FAQ

• Comment ce script sécurise-t-il le mot de passe ?
  • Il utilise perl pour crypter le mot de passe avant de créer l’utilisateur, ce qui renforce la sécurité.

• Le script peut-il gérer la création d’utilisateurs en masse ?
  • Tel qu’il est rédigé, il est conçu pour être créé par un seul utilisateur. Toutefois, il peut être modifié pour les opérations de masse.

• Est-il compatible avec toutes les distributions Linux ?
  • Le script devrait fonctionner sur la plupart des distributions Linux dotées de l’interpréteur de commandes Bash et d’utilitaires standard de gestion des utilisateurs.

Implications

Bien que ce script soit un outil puissant pour les administrateurs système, il est essentiel d’être conscient de ses implications en matière de sécurité. Une bonne gestion des privilèges des utilisateurs est cruciale pour la sécurité du système. Une mauvaise utilisation ou des erreurs dans le script peuvent entraîner l’octroi par inadvertance de permissions excessives.

Recommandations

• Testez toujours d’abord le script dans un environnement de non-production.
• Mettre en place un système de journalisation pour suivre l’utilisation et les résultats du script.
• Examiner et auditer régulièrement les comptes d’utilisateurs créés par le script.

Conclusion :

En conclusion, ce script illustre la manière dont l’automatisation peut rationaliser les tâches administratives dans les environnements Linux. Pour une gestion et une automatisation de l’informatique plus étendue, des solutions telles que NinjaOne fournissent les outils et l’infrastructure nécessaires, offrant un soutien solide pour des tâches telles que celles-ci, garantissant l’efficacité et la sécurité de la gestion des environnements informatiques.