Guida completa per professionisti IT per disabilitare gli account utente in Linux

La gestione degli account utente è un aspetto cruciale dell’amministrazione del sistema, soprattutto quando si tratta di garantire la sicurezza e l’integrità di un ambiente Linux. Disabilitare gli account utente non più in uso o potenzialmente compromessi è una pratica standard tra i professionisti IT e i fornitori di servizi gestiti (MSP).

In questo articolo analizzeremo uno script completo progettato per disabilitare gli account utente in Linux, fornendo una spiegazione approfondita della sua funzionalità, dei casi d’uso e delle best practice correlate.

Capire l’importanza della gestione degli account utente

In qualsiasi infrastruttura IT, la gestione degli account utente è fondamentale per mantenere la sicurezza e l’efficienza operativa. L’accesso non autorizzato o l’uso improprio degli account utente può portare a violazioni dei dati, perdita di informazioni sensibili e potenziali interruzioni del sistema. Pertanto, disabilitare gli account utente inattivi o compromessi è una misura proattiva per salvaguardare il sistema.

Il background dello script per disabilitare gli account utente in Linux

Lo script che stiamo esaminando è progettato per disabilitare un account utente specificato, cambiando la sua shell di login in /sbin/nologin e bloccando l’account. Questo processo impedisce all’utente di accedere, conservando l’account per una potenziale riattivazione o per scopi di verifica. Questo approccio è preferibile all’eliminazione totale, in quanto mantiene intatta la cronologia dell’account e i file correlati.

Lo script per disabilitare gli account utente in Linux:

#!/usr/bin/env bash

# Description: Disables a user account by changing its shell to /sbin/nologin and locking 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: "ReplaceMeWithUsernameToDisable"
#   Username of the user you would like to disable.
#

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

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

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

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

if [[ -n $usernameToDisable ]]; then
  _arg_userToDisable="$usernameToDisable"
fi

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

# Search for the user in the /etc/passwd file and ensure the user account is not already set to 'nologin'.
passwdEntry=$(grep -w "$_arg_userToDisable" /etc/passwd)
if [[ -z $passwdEntry ]]; then
  _PRINT_HELP=no die "[Error] User '$_arg_userToDisable' does not exist." 1
fi

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

# Check if the 'sudo' command is available on the system.
sudoAvailable=$(command -v sudo)

# If 'sudo' is available, check if the specified user has sudo privileges and is not explicitly forbidden from using sudo.
if [[ -n $sudoAvailable ]]; then
  sudoAccess=$(sudo -l -U "$_arg_userToDisable" | grep -v "is not allowed to run sudo")
fi

# Initialize a flag to check for the availability of another administrative user.
anotherAdminAvaliable=false

# If the user to disable is 'root' or if they have sudo access, proceed to check for other admin users.
if [[ "$_arg_userToDisable" == "root" || -n $sudoAccess ]]; then
 # Fetch all user accounts with UID >= 1000 (typically regular users) and exclude the specified user and 'nobody'.
  allAccounts=$(cut -d ":" -f1,3 /etc/passwd | grep -v -w "$_arg_userToDisable" | grep -v "nobody" | awk -F ':' '$2 >= 1000 {print $1}')

  # If the user to disable is not 'root', add 'root' to the list of all accounts if it is enabled and not set to 'nologin'.
  if [[ ! "$_arg_userToDisable" == "root" ]]; then
    enabled=$(grep -w "root" /etc/passwd | grep -v "nologin")
    if [[ -n $enabled ]]; then
      allAccounts=$(echo "$allAccounts"; echo "root")
    fi
  fi

  # Iterate over each account to check if there are other admin users available.
  for account in $allAccounts; do
    # Skip checking accounts if 'sudo' is not available.
    if [[ -z $sudoAvailable ]]; then
      continue
    fi

    # Check if the current account has sudo access.
    sudoAccess=$(sudo -l -U "$account" | grep -v "is not allowed to run sudo")
    if [[ -z $sudoAccess ]]; then
      continue
    fi

    # Check if the current account is enabled (i.e., not set to 'nologin').
    accountEnabled=$(grep -w "$account" /etc/passwd | grep -v "nologin")
    if [[ -z $accountEnabled ]]; then
      continue
    fi

    # If an admin account is available and enabled, set the flag to true.
    anotherAdminAvaliable="true"
  done

  # If no other admin users are available, output an error and suggest creating another admin account.
  if [[ $anotherAdminAvaliable == "false" ]]; then
    _PRINT_HELP=no die "[Error] No other admins available. Please create another account to administer the system." 1
  fi
fi

# Attempt to change the shell of the user to /sbin/nologin to disable login capabilities.
if ! usermod "$_arg_userToDisable" -s /sbin/nologin; then
  _PRINT_HELP=no die "[Error] Failed to change the shell for '$_arg_userToDisable' to /sbin/nologin." 1
fi

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

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

 

Analisi dettagliata dello script per disabilitare gli account utente in Linux

Impostazione iniziale e parsing dei parametri

Lo script per disabilitare gli account utente in Linux inizia con la definizione di una funzione di testo di aiuto (print_help) e di una die per gestire gli errori e visualizzare i relativi messaggi. La funzione parse_commandline elabora gli argomenti della riga di comando per identificare il nome utente dell’account da disattivare.

Convalida dell’account utente

Lo script per disabilitare gli account utente in Linux controlla quindi se il nome utente specificato è valido ed esiste nel sistema. Si assicura che il nome utente contenga solo i caratteri consentiti (lettere minuscole, cifre, trattini e trattini bassi) e ne verifica l’esistenza nel file /etc/passwd.

Garantire l’assenza di conflitti con gli account di amministrazione

Lo script per disabilitare gli account utente in Linux controlla inoltre se l’utente da disabilitare ha privilegi amministrativi. Verifica se ci sono altri account di amministrazione disponibili per evitare di bloccare l’accesso amministrativo essenziale.

Disabilitazione dell’account utente

Infine, lo script disabilita l’account utente cambiando la shell in /sbin/nologin e bloccando l’account. Verifica il successo di queste operazioni e fornisce un feedback.

Casi d’uso potenziali

Immagina uno scenario in cui un professionista IT deve disabilitare un account per un dipendente che ha lasciato l’azienda. Lo script per disabilitare gli account utente in Linux fornisce un metodo rapido ed efficiente per garantire che l’account venga disabilitato ma non eliminato. Ciò consente al team IT di conservare i dati e la cronologia dell’account dell’utente ai fini della conformità e della revisione.

Confronto con altri metodi

L’approccio tradizionale per disabilitare un account utente può comportare la modifica manuale del file /etc/passwd o l’esecuzione di più comandi. Questo script automatizza il processo per disabilitare gli account utente in Linux, riducendo il rischio di errore umano e garantendo la coerenza tra i diversi sistemi.

Domande frequenti

D: Questo script per disabilitare gli account utente in Linux può eliminare un account utente?

R: No, lo script disabilita l’account solo cambiando la shell e bloccandolo. L’eliminazione di un account richiederebbe ulteriori comandi.

D: È sicuro disabilitare l’account di root?

R: Disabilitare un account root può rendere il sistema ingestibile. Lo script per disabilitare gli account utente in Linux include controlli per verificare che sia disponibile un altro account amministratore prima di procedere.

D: Cosa succede se l’account utente è già disabilitato?

R: Lo script per disabilitare gli account utente in Linux controlla lo stato dell’account e notifica se l’account è già disabilitato, evitando operazioni ridondanti.

Implicazioni per la sicurezza informatica

Disabilitare gli account utente inattivi o compromessi è una misura di sicurezza fondamentale. Riduce la superficie di attacco e impedisce l’accesso non autorizzato, migliorando così la sicurezza generale dell’organizzazione.

Raccomandazioni

Quando utilizzi questo script per disabilitare gli account utente in Linux, assicurati:

• Che sia disponibile un altro account amministrativo.

• Di controllare e aggiornare regolarmente i criteri di gestione degli account utente.

• Di testare lo script per disabilitare gli account utente in Linux in un ambiente non di produzione prima di distribuirlo in un ambiente live.

Considerazioni finali

La gestione degli account utente è un aspetto fondamentale dell’amministrazione del sistema. Questo script semplifica il processo per disabilitare gli account utente in Linux, offrendo una soluzione affidabile e automatizzata. Strumenti come NinjaOne possono semplificare ulteriormente le operazioni IT, fornendo funzionalità complete di gestione e monitoraggio per garantire che i sistemi rimangano sicuri ed efficienti.

Seguendo le best practice e sfruttando script automatizzati come quello per disabilitare gli account utente in Linux, i professionisti IT possono mantenere un ambiente Linux sicuro e ben gestito, salvaguardando l’infrastruttura da potenziali minacce e garantendo una continuità operativa senza problemi.