Guida completa allo script: Creare un utente amministratore in Linux

Punti chiave

• Automatizza la creazione dell’utente amministratore: Semplifica il processo di aggiunta di nuovi utenti amministratori in ambienti Linux.
• Migliora l’efficienza e la precisione: Riduce gli sforzi manuali e minimizza il rischio di errore umano.
• Flessibilità dello script per creare un utente amministratore in Linux: Adattabile a varie esigenze, supporta diverse opzioni di utenti, password e gruppi.
• Focalizzato sulla sicurezza: Incorpora la crittografia delle password e richiede i privilegi di root, dando priorità alla sicurezza.
• Utilizzo versatile: Adatto sia ai singoli che agli MSP che gestiscono più sistemi Linux.
• Confronto con i metodi tradizionali: Offre una soluzione più coesa e scalabile rispetto ai comandi manuali o agli strumenti dell’interfaccia grafica.
• Domande frequenti: Chiarisce i problemi di sicurezza, operazioni in blocco e compatibilità.
• Implicazioni per la sicurezza: Sottolinea l’importanza di una corretta gestione dei privilegi e della verifica dell’uso degli script.
• Raccomandazioni sulle best practice: Consiglia di effettuare test, registrazioni e revisioni periodiche degli account.
• Integrazione con NinjaOne: Evidenzia come tali script siano complementari a piattaforme di gestione IT più ampie come NinjaOne.

L’amministrazione efficace dei sistemi Linux richiede spesso la creazione e la gestione di account utente, in particolare di quelli con privilegi amministrativi. Comprendere le sfumature di questo processo è fondamentale per gli amministratori di sistema e i professionisti IT. Lo script di oggi risponde a questa esigenza, fornendo un modo efficiente per aggiungere nuovi utenti amministratori in ambienti Linux.

Background

Nel mondo dell’IT, la gestione degli account utente è un compito fondamentale. Questo script per creare un utente amministratore in Linux è particolarmente importante per i professionisti IT e i fornitori di servizi gestiti (MSP) che spesso gestiscono diversi server o workstation Linux. L’automazione della creazione degli utenti amministratori non solo fa risparmiare tempo, ma riduce anche la probabilità di errore umano. La sua importanza non può essere sottovalutata negli scenari in cui la gestione rapida e sicura degli utenti è fondamentale.

Lo script per creare un utente amministratore in Linux:

#!/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/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>] [-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

 

Analisi dettagliata

Funzionalità dello script:

• Impostazione dell’ambiente: Lo script per creare un utente amministratore in Linux inizia con una riga di shebang(#!/usr/bin/env bash), che imposta l’ambiente per utilizzare Bash come linguaggio di scripting.
• Descrizione e utilizzo: Include commenti che spiegano il suo scopo: creare un nuovo utente amministratore aggiungendolo a un gruppo, tipicamente “sudo”.
• Definizioni delle funzioni:
  • die(): Gestisce gli scenari di uscita, mostrando messaggi di errore quando necessario.
  • begins_with_short_option(): Aiuta ad analizzare le opzioni della riga di comando.
  • print_help(): Visualizza le istruzioni d’uso.
• Inizializzazione delle variabili: Variabili come _arg_user, _arg_pass, _arg_group e _arg_disable vengono inizializzate.
• Analizzare gli argomenti della riga di comando: La funzione parse_commandline() itera sugli argomenti per impostare utente, password, gruppo e data di disattivazione.
• Operazione di creazione dell’utente:
  • Controlla se l’utente esiste.
  • In caso contrario, crea un nuovo utente e lo aggiunge al gruppo specificato.
  • Imposta facoltativamente una data di disattivazione per l’account utente.
• Controllo dei privilegi root: Assicura che lo script venga eseguito da un utente con privilegi root, un passaggio necessario per creare e modificare gli account utente.

Casi d’uso potenziali

Consideriamo un MSP che gestisce un complesso di server Linux per un cliente. Ricevono una richiesta di inserimento rapido di un nuovo team di sviluppatori che necessitano di accesso come amministratori. Utilizzando questo script, l’MSP può creare in modo efficiente account di amministratore individuali, assicurando a ciascun membro del team l’accesso appropriato senza interventi manuali, risparmiando tempo e riducendo al minimo gli errori.

Confronti

Normalmente per creare un utente amministratore in Linux sono richiesti diversi comandi manuali (useradd, passwd, usermod). Lo script automatizza questi passaggi in un unico processo coesivo. A differenza degli strumenti di gestione degli utenti basati su GUI, questo script può essere integrato in flussi di lavoro di automazione più ampi, rendendolo più flessibile e scalabile.

Domande frequenti

• In che modo lo script per creare un utente amministratore in Linux protegge la password?
  • Utilizza perl per criptare la password prima di creare l’utente, migliorando la sicurezza.

• Lo script può gestire la creazione di utenti in blocco?
  • Come menzionato, è stato progettato per la creazione di un singolo utente. Tuttavia, può essere modificato per le operazioni in blocco.

• È compatibile con tutte le distribuzioni Linux?
  • Lo script dovrebbe funzionare sulla maggior parte delle distribuzioni Linux che dispongono della shell Bash e delle utilità standard di gestione degli utenti.

Implicazioni

Sebbene lo script sia uno strumento potente per gli amministratori di sistema, è essenziale essere consapevoli delle sue implicazioni per la sicurezza. La gestione corretta dei privilegi degli utenti è fondamentale per la sicurezza del sistema. Un uso improprio o errori nello script potrebbero inavvertitamente concedere autorizzazioni eccessive.

Raccomandazioni

• Testa sempre prima lo script per creare un utente amministratore in Linux in un ambiente non di produzione.
• Implementa un sistema di logging per tracciare l’uso e l’output dello script.
• Esamina e verifica regolarmente gli account utente creati dallo script.

Considerazioni finali

In conclusione, questo script esemplifica come l’automazione possa semplificare le attività amministrative in ambienti Linux. Per una gestione e un’automazione IT più ampie, soluzioni come NinjaOne forniscono gli strumenti e l’infrastruttura necessari, offrendo un solido supporto per attività come queste, garantendo efficienza e sicurezza nella gestione degli ambienti IT.