Padroneggiare macOS: Semplificare la creazione di utenti amministratori con un efficiente scripting

Punti chiave

• Automatizza la creazione di utenti amministratori: Lo script per la creazione di utenti amministratori semplifica e standardizza il processo di aggiunta di nuovi utenti amministratori su Mac OS.
• Maggiore efficienza e sicurezza: Lo script per la creazione di utenti amministratori riduce gli errori manuali e garantisce pratiche di sicurezza coerenti nella creazione degli utenti.
• Parsing robusto degli argomenti: Lo script per la creazione di utenti amministratori gestisce efficacemente l’input dell’utente, compresi gli argomenti mancanti e le richieste di aiuto.
• Assegnazione di un ID utente univoco: Lo script per la creazione di utenti amministratori genera in modo intelligente ID univoci, fondamentali per la gestione degli utenti di Mac OS.
• Configurazione completa degli utenti: Lo script per la creazione di utenti amministratori imposta gli attributi necessari , come la shell, la home directory e l’appartenenza ai gruppi.
• Gestione degli errori e privilegi di root: Lo script per la creazione di utenti amministratori incorpora controlli di errore e richiede l’accesso di root, migliorando la sicurezza e l’affidabilità.
• Scalabile per MSP e professionisti IT: Ideale per gestire più sistemi e per risparmiare tempo e fatica in caso di implementazioni su larga scala.
• Rispetto ai metodi manuali: Lo script per la creazione di utenti amministratori offre un’alternativa più scalabile e a prova di errore ai metodi di creazione manuale degli utenti.
• Considerazioni sulla sicurezza: È importante proteggere lo script stesso, date le sue potenti capacità amministrative.
• Integrazione con gli strumenti di gestione: Lo script per la creazione di utenti amministratori può essere efficacemente integrato in piattaforme di gestione IT come NinjaOne per migliorare controllo e monitoraggio.

La creazione di account utente è un compito fondamentale nell’amministrazione dei sistemi, in quanto garantisce un accesso sicuro e organizzato alle risorse e ai servizi. Su Mac OS, questo processo assume ulteriori sfumature a causa della particolare architettura del sistema operativo e dei protocolli di sicurezza. L’automazione di questo processo non solo snellisce le attività amministrative, ma migliora anche la sicurezza e l’efficienza delle operazioni IT.

Background

Nel mondo dell’IT, in particolare per i Managed Service Provider (MSP) e i professionisti dell’IT, l’efficienza e la sicurezza sono fondamentali. Lo script per la creazione di utenti amministratori è uno script bash appositamente progettato per Mac OS, destinato ad automatizzare la creazione di un nuovo utente amministratore. Questo strumento è fondamentale perché standardizza la creazione degli utenti, riduce gli errori umani e protegge il sistema garantendo che tutti i passaggi e le autorizzazioni necessarie siano implementati correttamente.

Lo script per la creazione di utenti amministratori:

#!/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/it/condizioni-utilizzo/
# 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

 

Analisi dettagliata dello script per la creazione di utenti amministratori

Lo script opera in diverse fasi distinte:

• Parsing degli argomenti: Lo script per la creazione di utenti amministratori inizia con il parsing degli argomenti forniti durante l’invocazione. Questi argomenti includono il nome utente e la password del nuovo account, che sono fondamentali per la creazione dell’account. Lo script per la creazione di utenti amministratori gestisce in modo fluido gli argomenti mancanti, gli errori o le richieste di aiuto, guidando l’utente in modo appropriato.
• Generazione dell’ID utente: Per il nuovo utente viene generato un ID utente univoco. Mac OS richiede che ogni utente abbia un identificatore unico e questo script identifica in modo intelligente un ID inutilizzato analizzando quelli esistenti.
• Creazione dell’account: Una volta impostati il nome utente, la password e l’ID univoco, lo script per la creazione di utenti amministratori procede alla creazione dell’utente. Assegna una shell (/bin/bash), imposta un nome reale, un ID utente e un ID gruppo primario e specifica una home directory. Inoltre, aggiunge l’utente a diversi gruppi amministrativi, concedendo le autorizzazioni necessarie.
• Inizializzazione della home directory: Lo script per la creazione di utenti amministratori inizializza quindi la home directory del nuovo utente, un passaggio essenziale per la funzionalità dell’account utente.
• Gestione degli errori e delle autorizzazioni: Lo script per la creazione di utenti amministratori include una solida gestione degli errori, che assicura che lo script termini con messaggi e stati appropriati quando si verificano problemi. Tieni a mente che lo script per la creazione di utenti amministratori richiede i privilegi di root, a testimonianza della sua natura amministrativa.

Casi d’uso potenziali

Immagina un MSP incaricato di configurare più sistemi Mac OS per un nuovo cliente aziendale. Tradizionalmente, ciò richiedeva la creazione manuale di account utente su ogni macchina, un processo lungo e soggetto a errori. Con questo script per la creazione di utenti amministratori, l’MSP può impostare in modo rapido, uniforme e sicuro gli account di amministratore su tutti i computer, garantendo coerenza e risparmiando tempo.

Confronti

I metodi tradizionali per aggiungere utenti in Mac OS prevedono l’uso dell’interfaccia delle Preferenze di sistema o l’impiego di comandi di base del terminale. Pur essendo funzionali per singoli casi, questi metodi mancano di scalabilità e sono soggetti a incoerenza. Questo script automatizza il processo, assicurando che ogni account sia creato seguendo le best practice e con le esatte autorizzazioni richieste.

Domande frequenti

• Quanto è sicuro questo script per la creazione di utenti amministratori?
  • Lo script per la creazione di utenti amministratori è stato progettato tenendo conto della sicurezza, dato che richiede l’accesso root e gestisce con attenzione le informazioni sensibili come le password.
• Lo script può gestire la creazione di più utenti in una sola volta?
  • Come scritto, crea un utente per ogni invocazione. Tuttavia, può essere modificato o inserito in uno script più ampio per creare più utenti.

Implicazioni

Gli script automatizzati, pur essendo efficienti, comportano implicazioni per la sicurezza informatica. Se utilizzati in modo improprio o da utenti non autorizzati, potrebbero essere un vettore per la creazione di punti di accesso non autorizzati. Pertanto, la sicurezza dello script stesso è importante quanto la sicurezza del sistema su cui opera.

Raccomandazioni

• Esegui sempre script come questo attenendoti ai più elevati standard di sicurezza.
• Verifica e aggiorna regolarmente lo script per garantire la compatibilità con le ultime versioni di Mac OS.
• Limita l’accesso allo script al solo personale autorizzato.

Considerazioni finali

L’integrazione di strumenti come NinjaOne può aumentare l’utilità di script come questo. NinjaOne fornisce una piattaforma per la gestione delle operazioni IT, dove gli script possono essere distribuiti, monitorati e gestiti in modo efficiente. L’integrazione di script automatizzati in un framework di gestione più ampio come NinjaOne può migliorare in modo significativo l’efficienza IT e la sicurezza di un’organizzazione, soprattutto quando si tratta di ambienti diversi e complessi come quelli con più sistemi Mac OS.