Maîtriser macOS : Optimiser la création d’utilisateurs administrateurs grâce à des scripts efficaces

Points à retenir

• Automatise la création d’utilisateurs administratifs: Rationalise et standardise le processus d’ajout de nouveaux utilisateurs administrateurs sur Mac OS.
• Efficacité et sécurité accrues: Réduit les erreurs manuelles et garantit des pratiques de sécurité cohérentes lors de la création d’utilisateurs.
• Analyse robuste des arguments: Traite efficacement les données fournies par l’utilisateur, y compris les arguments manquants et les demandes d’aide.
• Attribution d’un identifiant unique à l’utilisateur: Génère intelligemment des identifiants uniques, essentiels pour la gestion des utilisateurs Mac OS.
• Configuration complète de l’utilisateur: Définit les attributs nécessaires à l’utilisateur, tels que le shell, le répertoire personnel et l’appartenance à un groupe.
• Gestion des erreurs et privilèges de la racine: Il intègre des contrôles d’erreur et exige un accès root, ce qui renforce la sécurité et la fiabilité.
• Évolutif pour les MSP et les professionnels de l’informatique: Idéal pour gérer plusieurs systèmes, ce qui permet d’économiser du temps et des efforts lors de déploiements à grande échelle.
• Par rapport aux méthodes manuelles: Offre une alternative plus évolutive et à l’abri des erreurs aux méthodes manuelles de création d’utilisateurs.
• Du côté de la sécurité : Il est important de sécuriser le script lui-même, étant donné ses puissantes capacités administratives.
• Intégration avec les outils de gestion: Peut être intégré efficacement dans des plates-formes de gestion informatique telles que NinjaOne pour un contrôle et une surveillance améliorés.

La création de comptes d’utilisateurs est une tâche fondamentale dans l’administration des systèmes, car elle garantit un accès sécurisé et organisé aux ressources et aux services. Sur Mac OS, ce processus comporte des nuances supplémentaires en raison de l’architecture unique du système d’exploitation et des protocoles de sécurité. L’automatisation de ce processus permet non seulement de rationaliser les tâches administratives, mais aussi de renforcer la sécurité et l’efficacité des opérations informatiques.

Contexte

Dans le monde de l’informatique, en particulier pour les fournisseurs de services gérés (MSP) et les professionnels de l’informatique, l’efficacité et la sécurité sont primordiales. Le script dont il est question ici est un script bash spécialement conçu pour Mac OS, destiné à automatiser la création d’un nouvel utilisateur administrateur. Cet outil est essentiel car il permet de normaliser la création d’utilisateurs, de réduire les erreurs humaines et de sécuriser le système en veillant à ce que toutes les étapes et autorisations nécessaires soient correctement mises en œuvre.

Le script :

#!/usr/bin/env bash
#
# Description: Create a new admin user for Mac.
# 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>] [-h|--help]
# -u, --user: User Name for new user account. (no default)
# -p, --pass: Password for new user 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
}

getHiddenUserUid() {
    local __UniqueIDs
    __UniqueIDs=$(dscl . -list /Users UniqueID | awk '{print $2}' | sort -ugr)

    local __NewUID
    for __NewUID in $__UniqueIDs; do
        if [[ $__NewUID -lt 499 ]]; then
            break
        fi
    done

    echo $((__NewUID + 1))
}

_arg_user=
_arg_pass=

# 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>] [-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' "-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}"
            ;;
        # 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 [[ -n "${username}" ]]; then
    _arg_user=$username
fi
if [[ -n "${password}" ]]; then
    _arg_pass=$password
fi

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

UniqueID=$(getHiddenUserUid)
if [ "$(id -u)" -eq 0 ]; then
    if dscl . -create /Users/"$_arg_user"; then
        dscl . -create /Users/"$_arg_user" UserShell /bin/bash
        dscl . -create /Users/"$_arg_user" RealName "$_arg_user"
        dscl . -create /Users/"$_arg_user" UniqueID "$UniqueID"
        dscl . -create /Users/"$_arg_user" PrimaryGroupID 20
        dscl . -create /Users/"$_arg_user" NFSHomeDirectory /Users/"$_arg_user"
        dscl . -passwd /Users/"$_arg_user" "$_arg_pass"
        dscl . -append /Groups/admin GroupMembership "$_arg_user"
        dscl . -append /Groups/_lpadmin GroupMembership "$_arg_user"
        dscl . -append /Groups/_appserveradm GroupMembership "$_arg_user"
        dscl . -append /Groups/_appserverusr GroupMembership "$_arg_user"
        createhomedir -c 2>&1 | grep -v "shell-init"
    else
        echo "ERROR: Failed to create user. Already exists?"
        exit 1
    fi
else
    echo "Only root may add a user to the system."
    exit 2
fi

 

Description détaillée

Le script fonctionne en plusieurs phases distinctes :

• Analyse des arguments: Il commence par analyser les arguments fournis lors de son invocation. Ces arguments comprennent le nom d’utilisateur et le mot de passe du nouveau compte, qui sont essentiels pour la création du compte. Le script gère élégamment les arguments manquants, les erreurs ou les demandes d’aide, en guidant l’utilisateur de manière appropriée.
• Génération de l’ID de l’utilisateur: Un identifiant unique est généré pour le nouvel utilisateur. Mac OS exige que chaque utilisateur ait un identifiant unique, et ce script identifie intelligemment un identifiant inutilisé en analysant les identifiants existants.
• Création de compte: Une fois le nom d’utilisateur, le mot de passe et l’identifiant unique définis, le script procède à la création de l’utilisateur. Il attribue un shell(/bin/bash), définit un nom réel, un identifiant d’utilisateur et un identifiant de groupe principal, et spécifie un répertoire personnel. Surtout, il ajoute l’utilisateur à plusieurs groupes administratifs, en lui accordant les autorisations nécessaires.
• Initialisation du répertoire personnel: Le script initialise ensuite le répertoire personnel du nouvel utilisateur, une étape essentielle pour la fonctionnalité du compte d’utilisateur.
• Gestion des erreurs et autorisations: Il comprend une gestion robuste des erreurs, garantissant que le script se termine avec les messages et les statuts appropriés lorsqu’il rencontre des problèmes. Notamment, le script requiert les privilèges de l’administrateur (root), ce qui reflète sa nature administrative.

Cas d’utilisation potentiels

Imaginez un MSP chargé d’installer plusieurs systèmes Mac OS pour une nouvelle entreprise cliente. Traditionnellement, cela nécessitait la création manuelle de comptes d’utilisateurs sur chaque machine, un processus qui prend du temps et qui est source d’erreurs. Grâce à ce script, le MSP peut configurer rapidement, uniformément et en toute sécurité les comptes d’administrateur sur toutes les machines, ce qui garantit la cohérence et permet de gagner un temps considérable.

Comparaisons

Les méthodes traditionnelles d’ajout d’utilisateurs sous Mac OS consistent à utiliser l’interface des Préférences Système ou à employer des commandes de terminal de base. Bien qu’elles soient fonctionnelles pour des cas particuliers, ces méthodes manquent d’évolutivité et sont sujettes à des incohérences. Ce script automatise le processus, en veillant à ce que chaque compte soit créé selon les meilleures pratiques et avec les autorisations exactes requises.

FAQ

• Quel est le niveau de sécurité de ce script pour la création d’utilisateurs administrateurs ?
  • Le script est conçu dans un souci de sécurité, nécessitant un accès root et traitant avec précaution les informations sensibles telles que les mots de passe.
• Le script peut-il gérer plusieurs créations d’utilisateurs en une seule fois ?
  • Tel qu’il est écrit, il crée un utilisateur par invocation. Cependant, il peut être modifié ou mis en boucle dans un script plus large afin de créer plusieurs utilisateurs.

Implications

Les scripts automatisés, bien qu’efficaces, ont des conséquences sur la sécurité informatique. S’ils sont mal utilisés ou si des utilisateurs non autorisés y accèdent, ils peuvent constituer un vecteur de création de points d’accès non autorisés. Il est donc tout aussi important de sécuriser le script lui-même que le système sur lequel il fonctionne.

Recommandations

• Exécutez toujours ces scripts en respectant les normes de sécurité les plus strictes.
• Auditer et mettre à jour régulièrement le script pour garantir sa compatibilité avec les dernières versions de Mac OS.
• Limiter l’accès au script aux seules personnes autorisées.

Conclusion :

L’intégration d’outils tels que NinjaOne peut accroître l’utilité des scripts de ce type. NinjaOne fournit une plateforme pour la gestion des opérations informatiques, où les scripts peuvent être déployés, surveillés et gérés efficacement. L’intégration de scripts automatisés dans un cadre de gestion plus large tel que NinjaOne peut améliorer de manière significative l’efficacité et la sécurité informatique d’une organisation, en particulier lorsqu’il s’agit d’environnements divers et complexes tels que plusieurs systèmes Mac OS.