Guide für IT-Experten: Wie man Benutzerkonten in Linux deaktivieren kann

Die Verwaltung von Benutzerkonten ist ein wichtiger Aspekt des System-Managements, insbesondere wenn es darum geht, die Sicherheit und Integrität einer Linux-Umgebung zu gewährleisten. Das Deaktivieren von Benutzerkonten, die nicht mehr verwendet werden oder möglicherweise kompromittiert sind, ist ein Standardverfahren unter IT-Experten und Managed Service Providern (MSPs).

In diesem Blogbeitrag wird ein umfassendes Skript zum Deaktivieren von Benutzerkonten unter Linux vorgestellt. Wir befassen uns mit einer detaillierten Erklärung seiner Funktionalität, Anwendungsfällen und Best Practices.

Die Bedeutung der Benutzerkontenverwaltung verstehen

In jeder IT-Infrastruktur ist die Verwaltung von Benutzerkonten essenziell für die Aufrechterhaltung der Sicherheit und der betrieblichen Effizienz. Unbefugter Zugriff oder Missbrauch von Benutzerkonten kann zu Datenschutzverletzungen, dem Verlust vertraulicher Informationen und möglichen Systemausfällen führen. Daher ist die Deaktivierung inaktiver oder gefährdeter Benutzerkonten eine proaktive Maßnahme zum Schutz des Systems.

Kontext

Das Skript, das wir untersuchen, soll ein bestimmtes Benutzerkonto deaktivieren, indem es seine Anmelde-Shell in ‘/sbin/nologin’ ändert und das Konto sperrt. Dieser Vorgang verhindert, dass sich die Benutzer:innen anmelden, während das Konto für eine mögliche Reaktivierung oder zu Prüfungszwecken erhalten bleibt. Dieser Ansatz wird gegenüber einer vollständigen Löschung bevorzugt, da der Kontoverlauf und die zugehörigen Dateien intakt bleiben.

Das Skript zum Deaktivieren von Benutzerkonten unter 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

 

Detailansicht

Ersteinrichtung und Parameter-Parsen

Das Skript beginnt mit der Definition einer Hilfetextfunktion (print_help) und einer Stop-Funktion (die) zur Behandlung von Fehlern und zur Anzeige der entsprechenden Warnmeldungen. Die Funktion ‘parse_commandline’ verarbeitet Befehlszeilenargumente, um den Benutzernamen des zu deaktivierenden Kontos zu ermitteln.

Validierung des Benutzerkontos

Das Skript prüft dann, ob der angegebene Benutzername gültig ist und im System existiert. Es stellt sicher, dass der Benutzername nur erlaubte Zeichen enthält (Kleinbuchstaben, Ziffern, Bindestriche und Unterstriche) und überprüft seine Existenz in der Datei ‘/etc/passwd’.

Es wird sichergestellt, dass keine Konflikte mit Admin-Konten auftreten.

Das Skript überprüft außerdem, ob die zu deaktivierenden Benutzer:innen über Administratorrechte verfügen. Wenn es der Fall ist, sucht das Skript nach anderen Administratorkonten, um zu verhindern, dass wichtige administrative Zugriffe gesperrt werden.

Deaktivieren des Benutzerkontos

Schließlich deaktiviert das Skript das Benutzerkonto, indem es die Shell in ‘/sbin/nologin’ ändert und das Konto sperrt. Es prüft dann den Erfolg dieser Vorgänge und gibt Feedback.

Potenzielle Anwendungsfälle

Stellen Sie sich ein Szenario vor, in dem ein IT-Experte das Konto eines Mitarbeiters deaktivieren muss, der das Unternehmen verlassen hat. Das Skript bietet eine optimierte und effiziente Methode, um zu gewährleisten, dass das Konto deaktiviert wird, ohne dass man es auch löscht. Auf diese Weise kann das IT-Team die Daten und den Kontoverlauf der Benutzer:innen für Compliance- und Audit-Zwecke aufbewahren.

Vergleiche mit anderen Methoden

Der herkömmliche Ansatz zur Deaktivierung eines Benutzerkontos kann die manuelle Bearbeitung der Datei ‘/etc/passwd’ oder die Ausführung mehrerer Befehle beinhalten. Dieses Skript automatisiert den Prozess, verringert das Risiko menschlichen Versagens und gewährleistet die Konsistenz zwischen verschiedenen Systemen.

FAQs

F: Kann dieses Skript ein Benutzerkonto löschen?

A: Nein, das Skript deaktiviert das Konto nur, indem es die Shell ändert und sperrt. Das Löschen eines Kontos würde zusätzliche Befehle erfordern.

F: Ist es sicher, das Root-Konto zu deaktivieren?

A: Das Deaktivieren des Root-Kontos kann dazu führen, dass das System nicht mehr verwaltbar ist. Das Skript enthält Überprüfungen, um dafür zu sorgen, dass ein anderes Administratorkonto verfügbar ist, bevor es fortfährt.

F: Was ist, wenn das Benutzerkonto bereits deaktiviert ist?

A: Das Skript prüft den Kontostatus und meldet, wenn das Konto bereits deaktiviert ist, um redundante Vorgänge zu vermeiden.

Auswirkungen auf die IT-Sicherheit

Die Deaktivierung inaktiver oder kompromittierter Benutzerkonten ist eine wichtige Sicherheitsmaßnahme. Es reduziert die Angriffsfläche und verhindert unbefugten Zugriff, wodurch die allgemeine Sicherheitslage des Unternehmens verbessert wird.

Empfehlungen

Wenn Sie dieses Skript verwenden, stellen Sie sicher:

• Dass Sie ein anderes Administratorkonto zur Verfügung haben.

• Dass Sie Ihre Richtlinien zur Verwaltung von Benutzerkonten regelmäßig überprüfen und aktualisieren.

• Dass Sie das Skript in einer Staging-Umgebung testen, bevor Sie es in einer Live-Umgebung einsetzen.

Abschließende Überlegungen

Die Verwaltung von Benutzerkonten ist ein grundlegender Aspekt des System-Managements. Dieses Skript vereinfacht das Deaktivieren von Benutzerkonten unter Linux und bietet eine leistungsstarke und automatisierte Lösung. Tools wie NinjaOne können den IT-Betrieb weiter optimieren und bieten umfassende Verwaltungs- und Überwachungsfunktionen, um dafür zu sorgen, dass Ihre Systeme sicher und effizient bleiben.

Durch die Einhaltung von Best Practices und den Einsatz automatisierter Skripte können IT-Experten eine sichere und gut verwaltete Linux-Umgebung aufrechterhalten, die ihre Infrastruktur vor potenziellen Bedrohungen schützt und eine reibungslose Betriebskontinuität gewährleistet.