Guide für IT-Experten: Skript zur sicheren Token-Erstellung unter macOS

In der heutigen IT-Welt ist die Verwaltung von Benutzerkonten und die Gewährleistung eines sicheren Zugriffs entscheidend für die Aufrechterhaltung einer stabilen Systemsicherheit. Einer der wichtigsten Aspekte dieser Verwaltung unter macOS ist die Verwendung sicherer Token. Sichere Token sind für verschiedene Sicherheitsfunktionen unerlässlich, einschließlich der Aktivierung von FileVault und der Durchführung bestimmter Verwaltungsaufgaben.

Dieser Blogbeitrag befasst sich mit einem Skript, das den Prozess der Gewährung von sicherem Token-Zugriff auf Benutzerkonten unter macOS automatisiert, und erläutert dessen Bedeutung, Funktionalität und Anwendungsfälle für IT-Experten und Managed Service Provider (MSPs).

Kontext

Sichere Token sind eine Sicherheitsfunktion von macOS, die zusätzliche Authentifizierungsmaßnahmen bietet, insbesondere im Zusammenhang mit der FileVault-Verschlüsselung. Für IT-Experten und MSPs ist die Verwaltung dieser Token für die Aufrechterhaltung sicherer Umgebungen auf zahlreichen Geräten unerlässlich.

Das mitgelieferte Skript vereinfacht den Prozess der Gewährung von sicherem Token-Zugriff auf ein Benutzerkonto und erstellt das Konto sogar, wenn es noch nicht existiert. Diese Automatisierung ist besonders in großen Umgebungen von Vorteil, in denen eine manuelle Konfiguration unpraktisch und zeitaufwändig wäre.

Das Skript zur sicheren Token-Erstellung unter macOS

#!/usr/bin/env bash
# Description: Grants secure token access to Service Account. Account will be created if it doesn't exist. Service Accounts will not show up at the desktop login.
# Release Notes: Initial Release
#
# Custom Fields:
#  New Account Password Custom Field: A secure custom field that stores the password for the new user account.
#  Optional Authentication Account Username Custom Field: A secure custom field that stores the username of the admin account that has secure token already on the device.
#
# Parameters:
#  username: Username to grant secure token access to
#  password: Password of user to grant secure token access to
#  adminuser: (Optional) Secure token Admin username - leave blank to prompt local user
#  adminpassword: (Optional) Secure token Admin password - leave blank to prompt local user
#
# Usage: ./Create-SecureTokenAccount.sh <-u|--username <arg>> <-p|--password <arg>> [-a|--adminuser <arg>] [-d|--adminpassword <arg>]
# <> are required
# [] are optional
# Example: ./Create-SecureTokenAccount.sh --username test --password Password1 --adminuser admin --adminpassword Password2
#
# Notes:
# 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).
#
#

die() {
    local _ret="${2:-1}"
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    echo "$1" >&2
    exit "${_ret}"
}

begins_with_short_option() {
    local first_option all_short_options='upadvh'
    first_option="${1:0:1}"
    test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0
}

GetCustomField() {
    customfieldName=$1
    dataPath=$(printenv | grep -i NINJA_DATA_PATH | awk -F = '{print $2}')
    value=""
    if [ -e "${dataPath}/ninjarmm-cli" ]; then
        value=$("${dataPath}"/ninjarmm-cli get "$customfieldName")
    else
        value=$(/Applications/NinjaRMMAgent/programdata/ninjarmm-cli get "$customfieldName")
    fi
    if [[ "${value}" == *"Unable to find the specified field"* ]]; then
        echo ""
        return 1
    else
        echo "$value"
    fi
}

# THE DEFAULTS INITIALIZATION - OPTIONALS
_arg_username=
_arg_password=
_arg_adminuser=
_arg_adminpassword=

print_help() {
    printf '%s\n' "Grants secure token access to an account. Account will be created if it doesn't exist."
    printf 'Usage: %s <-u|--username <arg>> <-p|--password <arg>> [-a|--adminuser <arg>] [-d|--adminpassword <arg>] [-h|--help]\n' "$0"
    printf '\t%s\n' "-u, --username: Username to grant secure token access to. (Required)"
    printf '\t%s\n' "-p, --password: Password of user to grant secure token access to. (Required)"
    printf '\t%s\n' "-a, --adminuser: (Optional) Secure token Admin username. (Leave blank to prompt local user)"
    printf '\t%s\n' "-d, --adminpassword: (Optional) Secure token Admin password. (Leave blank to prompt local user)"
    printf '\t%s\n' "-h, --help: Prints help"
}

parse_commandline() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        -u | --username)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_username="$2"
            shift
            ;;
        --username=*)
            _arg_username="${_key##--username=}"
            ;;
        -u*)
            _arg_username="${_key##-u}"
            ;;
        -p | --password)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_password="$2"
            shift
            ;;
        --password=*)
            _arg_password="${_key##--password=}"
            ;;
        -p*)
            _arg_password="${_key##-p}"
            ;;
        -a | --adminuser)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_adminuser="$2"
            shift
            ;;
        --adminuser=*)
            _arg_adminuser="${_key##--adminuser=}"
            ;;
        -a*)
            _arg_adminuser="${_key##-a}"
            ;;
        -d | --adminpassword)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_adminpassword="$2"
            shift
            ;;
        --adminpassword=*)
            _arg_adminpassword="${_key##--adminpassword=}"
            ;;
        -d*)
            _arg_adminpassword="${_key##-d}"
            ;;
        -h | --help)
            print_help
            exit 0
            ;;
        -h*)
            print_help
            exit 0
            ;;
        *)
            _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

parse_commandline "$@"

# Get Script Variables and override parameters
if [[ -n $(printenv | grep -i newAccountUsername | awk -F = '{print $2}') ]]; then
    _arg_username=$(printenv | grep -i newAccountUsername | awk -F = '{print $2}')
fi
if [[ -n $(printenv | grep -i newAccountPasswordCustomField | awk -F = '{print $2}') ]]; then
    # Get the password from the custom field
    if ! _arg_password=$(GetCustomField "$(printenv | grep -i newAccountPasswordCustomField | awk -F = '{print $2}')"); then
        # Exit if the custom field is empty
        if [[ -z "${_arg_password}" ]]; then
            echo "[Error] Custom Field ($(printenv | grep -i newAccountPasswordCustomField | awk -F = '{print $2}')) was not found. Please check that the custom field contains a password."
            exit 1
        fi
        # Exit if the custom field is not found
        echo "[Error] Custom Field ($(printenv | grep -i newAccountPasswordCustomField | awk -F = '{print $2}')) was not found. Please check the custom field name."
        exit 1
    fi
fi
if [[ -n $(printenv | grep -i optionalAuthenticationAccountUsername | awk -F = '{print $2}') ]]; then
    _arg_adminuser=$(printenv | grep -i optionalAuthenticationAccountUsername | awk -F = '{print $2}')
fi
if [[ -n $(printenv | grep -i optionalAuthenticationAccountPasswordCustomField | awk -F = '{print $2}') ]]; then
    # Get the password from the custom field
    if ! _arg_adminpassword=$(GetCustomField "$(printenv | grep -i optionalAuthenticationAccountPasswordCustomField | awk -F = '{print $2}')"); then
        # Exit if the custom field is empty
        if [[ -z "${_arg_adminpassword}" ]]; then
            echo "[Error] Custom Field ($(printenv | grep -i optionalAuthenticationAccountPasswordCustomField | awk -F = '{print $2}')) was not found. Please check that the custom field contains a password."
            exit 1
        fi
        # Exit if the custom field is not found
        echo "[Error] Custom Field ($(printenv | grep -i optionalAuthenticationAccountPasswordCustomField | awk -F = '{print $2}')) was not found. Please check the custom field name."
        exit 1
    fi
fi

# If both username and password are empty
if [[ -z "${_arg_username}" ]]; then
    echo "[Error] User Name is required."
    if [[ -z "${_arg_password}" ]]; then
        echo "[Error] Password is required, please set the password in the secure custom field."
    fi
    exit 1
fi

# If username is not empty and password is empty
if [[ -n "${_arg_username}" ]] && [[ -z "${_arg_password}" ]]; then
    echo "[Error] Password is required, please set the password in the secure custom field."
    exit 1
fi

# If username is not empty and password is empty
if [[ -n "${_arg_adminuser}" ]] && [[ -z "${_arg_adminpassword}" ]]; then
    echo "[Error] Password is required, please set the password in the secure custom field."
    exit 1
fi

UserAccount=$_arg_username
UserPass=$_arg_password
UserFullName="ServiceAccount"
secureTokenAdmin=$_arg_adminuser
secureTokenAdminPass=$_arg_adminpassword
macOSVersionMajor=$(sw_vers -productVersion | awk -F . '{print $1}')
macOSVersionMinor=$(sw_vers -productVersion | awk -F . '{print $2}')
macOSVersionBuild=$(sw_vers -productVersion | awk -F . '{print $3}')

# Check script prerequisites.

# Exits if macOS version predates the use of SecureToken functionality.
# Exit if macOS < 10.
if [ "$macOSVersionMajor" -lt 10 ]; then
    echo "[Warn] macOS version ${macOSVersionMajor} predates the use of SecureToken functionality, no action required."
    exit 0
# Exit if macOS 10 < 10.13.4.
elif [ "$macOSVersionMajor" -eq 10 ]; then
    if [ "$macOSVersionMinor" -lt 13 ]; then
        echo "[Warn] macOS version ${macOSVersionMajor}.${macOSVersionMinor} predates the use of SecureToken functionality, no action required."
        exit 0
    elif [ "$macOSVersionMinor" -eq 13 ] && [ "$macOSVersionBuild" -lt 4 ]; then
        echo "[Warn] macOS version ${macOSVersionMajor}.${macOSVersionMinor}.${macOSVersionBuild} predates the use of SecureToken functionality, no action required."
        exit 0
    fi
fi

# Exits if $UserAccount already has SecureToken.
if sysadminctl -secureTokenStatus "$UserAccount" 2>&1 | grep -q "ENABLED"; then
    echo "${UserAccount} already has a SecureToken. No action required."
    exit 0
fi

# Exits with error if $secureTokenAdmin does not have SecureToken
# (unless running macOS 10.15 or later, in which case exit with explanation).

if [ -n "$secureTokenAdmin" ]; then
    if sysadminctl -secureTokenStatus "$secureTokenAdmin" 2>&1 | grep -q "DISABLED"; then
        if [ "$macOSVersionMajor" -gt 10 ] || [ "$macOSVersionMajor" -eq 10 ] && [ "$macOSVersionMinor" -gt 14 ]; then
            echo "[Warn] Neither ${secureTokenAdmin} nor ${UserAccount} has a SecureToken, but in macOS 10.15 or later, a SecureToken is automatically granted to the first user to enable FileVault (if no other users have SecureToken), so this may not be necessary. Try enabling FileVault for ${UserAccount}. If that fails, see what other user on the system has SecureToken, and use its credentials to grant SecureToken to ${UserAccount}."
            exit 0
        else
            echo "[Error] ${secureTokenAdmin} does not have a valid SecureToken, unable to proceed. Please update to another admin user with SecureToken."
            exit 1
        fi
    else
        echo "[Info] Verified ${secureTokenAdmin} has SecureToken."
    fi
fi

# Creates a new user account.
create_user() {
    # Check if the user account exists
    if id "$1" >/dev/null 2>&1; then
        echo "[Info] Found existing user account $1."
    else
        echo "[Warn] Account $1 doesn't exist. Attempting to create..."
        # Create a new user
        dscl . -create /Users/"$1"
        # Add the display name of the User
        dscl . -create /Users/"$1" RealName "$3"
        # Replace password_here with your desired password to set the password for this user
        dscl . -passwd /Users/"$1" "$2"
        # Set the Unique ID for the New user. Replace with a number that is not already taken.
        LastID=$(dscl . -list /Users UniqueID | sort -nr -k 2 | head -1 | grep -oE '[0-9]+$')
        NextID=$((LastID + 1))
        dscl . -create /Users/"$1" UniqueID $NextID
        # Set the group ID for the user
        dscl . -create /Users/"$1" PrimaryGroupID 20
        # Append the User with admin privilege. If this line is not included the user will be set as standard user.
        # sudo dscl . -append /Groups/admin GroupMembership "$1"
        echo "[Info] Account $1 created."
    fi
}
# Adds SecureToken to target user.
securetoken_add() {
    if [ -n "$3" ]; then
        # Admin user name was given. Do not prompt the user.
        sysadminctl \
            -secureTokenOn "$1" \
            -password "$2" \
            -adminUser "$3" \
            -adminPassword "$4"
    else
        # Admin user name was not given. Prompt the local user.
        currentUser=$(stat -f%Su /dev/console)
        currentUserUID=$(id -u "$currentUser")
        launchctl asuser "$currentUserUID" sudo -iu "$currentUser" \
            sysadminctl \
            -secureTokenOn "$1" \
            -password "$2" \
            interactive
    fi
    # Verify successful SecureToken add.
    secureTokenCheck=$(sysadminctl -secureTokenStatus "${1}" 2>&1)
    if echo "$secureTokenCheck" | grep -q "DISABLED"; then
        echo "[Error] Failed to add SecureToken to ${1}. Please rerun policy; if issue persists, a manual SecureToken add will be required to continue."
        exit 126
    elif echo "$secureTokenCheck" | grep -q "ENABLED"; then
        echo "[Info] Successfully added SecureToken to ${1}."
    else
        echo "[Error] Unexpected result, unable to proceed. Please rerun policy; if issue persists, a manual SecureToken add will be required to continue."
        exit 1
    fi
}

# Create new user if it doesn't already exist.
create_user "$UserAccount" "$UserPass" "$UserFullName"
# Add SecureToken using provided credentials.
securetoken_add "$UserAccount" "$UserPass" "$secureTokenAdmin" "$secureTokenAdminPass"

 

Detailansicht

Überblick über das Skript

Das thematisierte Skript wurde entwickelt, um sicheren Token-Zugriff auf ein Benutzerkonto unter macOS zu gewähren, mit der Möglichkeit, das Konto zu erstellen, wenn es noch nicht existiert. Hier finden Sie eine detaillierte Aufschlüsselung der Funktionsweise des Skripts:

1. Parameter-Parsen: Das Skript beginnt mit der Definition einer ‘die’-Funktion zur Fehlerbehandlung und einer print_help-Funktion zur Anzeige von Nutzungsinformationen. Es analysiert dann die Befehlszeilenargumente, um den Benutzernamen, das Passwort und optional den Benutzernamen und das Passwort des Administrators zu extrahieren.
2. Umgebungsvariablen: Es wird geprüft, ob Umgebungsvariablen vorhanden sind, die die Befehlszeilenparameter überschreiben können. Wenn bestimmte Umgebungsvariablen gesetzt sind, ruft das Skript ihre Werte ab, um sie als Parameter zu verwenden.
3. macOS-Versionsprüfung: Das Skript überprüft die macOS-Version, um sicherzustellen, dass sie die Secure-Token-Funktionalität unterstützt. Es wird beendet, wenn die macOS-Version zu alt ist, um sichere Token zu verwenden.
4. Prüfung des Status von sicheren Token: Es wird geprüft, ob das angegebene Benutzerkonto bereits über ein sicheres Token verfügt. Wenn das der Fall ist, wird das Skript beendet, da keine weiteren Maßnahmen erforderlich sind.
5. Prüfung des Tokens vom Admin-Benutzer: Wenn ein Admin-Benutzername angegeben wird, prüft das Skript, ob dieser Admin-Benutzer ein sicheres Token besitzt. Ist dies nicht der Fall, wird es mit einem Fehler beendet, es sei denn, die macOS-Version ist 10.15 oder höher. In dieser Situation wird ein anderer Prozess empfohlen.
6. Erstellung eines Benutzerkontos: Das Skript enthält eine Funktion zum Anlegen eines neuen Benutzerkontos, falls dieses noch nicht existiert. Es weist dem Konto eine eindeutige ID zu, legt ein Passwort fest und konfiguriert andere notwendige Attribute.
7. Erteilung eines sicheren Tokens: Das Skript versucht, dem angegebenen Benutzerkonto unter Verwendung der angegebenen Anmeldeinformationen ein sicheres Token zu gewähren. Wenn der Admin-Benutzername angegeben ist, werden diese Anmeldeinformationen verwendet. Andernfalls wird der lokale Benutzer zur Authentifizierung aufgefordert.

Potenzielle Anwendungsfälle

Stellen Sie sich einen IT-Experten namens Alex vor, der eine Vielfalt von macOS-Geräten für ein großes Unternehmen verwaltet. Alex muss sicherstellen, dass alle Benutzerkonten auf diesen Geräten über sichere Token für die FileVault-Verschlüsselung verfügen. Das manuelle Überprüfen und Gewähren von Sicherheits-Tokens auf jedem Gerät wäre unglaublich zeitaufwändig.

Durch die Bereitstellung dieses Skripts über ein zentrales Verwaltungs-Tool kann Alex den Prozess automatisieren und sicherstellen, dass alle Benutzerkonten im gesamten Unternehmen über die erforderlichen sicheren Token verfügen und somit die Sicherheitsrichtlinien des Unternehmens eingehalten werden.

Vergleiche

Andere Methoden zur Gewährung sicherer Token erfordern in der Regel einen manuellen Eingriff über die macOS-Systemeinstellungen oder die Verwendung von sysadminctl-Befehlen für jeden einzelnen Benutzer. Diese Methoden funktionieren zwar, sind aber für die Verwaltung einer großen Anzahl von Geräten nicht skalierbar. Das Skript automatisiert diese Schritte, macht sie effizienter und verringert die Wahrscheinlichkeit menschlichen Versagens.

FAQs

• Was passiert, wenn das Benutzerkonto bereits existiert?

  Das Skript prüft, ob das Benutzerkonto vorhanden ist, und überspringt den Erstellungsschritt, wenn es bereits besteht.

• Kann ich dieses Skript auf älteren Versionen von macOS verwenden?

  Das Skript enthält Prüfungen, um sicherzustellen, dass es nur auf macOS-Versionen läuft, die sichere Token unterstützen, insbesondere macOS 10.13.4 und höher.

• Was passiert, wenn der Administrator kein sicheres Token hat?

  Das Skript wird mit einer Fehlermeldung beendet, wenn der Admin-Benutzer kein sicheres Token hat, außer unter macOS 10.15 oder höher, wo ein alternatives Verfahren vorgeschlagen wird.

Folgen

Die Gewährung von sicheren Token an Benutzerkonten ist entscheidend für die Aktivierung von FileVault und die sichere Durchführung von Verwaltungsaufgaben. Die Automatisierung dieses Prozesses trägt dazu bei, hohe Sicherheitsstandards aufrechtzuerhalten, die Einhaltung von Unternehmensrichtlinien zu gewährleisten und das Risiko eines unbefugten Zugriffs zu verringern.

Empfehlungen

• Aktualisieren Sie das Skript regelmäßig: Stellen Sie sicher, dass das Skript mit den neuesten macOS-Änderungen und Sicherheitspraktiken auf dem neuesten Stand gehalten wird.

• Sichere benutzerdefinierte Felder: Verwenden Sie sichere benutzerdefinierte Felder, um vertrauliche Informationen wie Passwörter zu speichern.

• Zentralisierte Verwaltung: Stellen Sie das Skript über ein zentrales Verwaltungs-Tool bereit, um für die Konsistenz auf allen Geräten zu sorgen.

Abschließende Überlegungen

Die Automatisierung des Prozesses der Gewährung von sicheren Token mit diesem Skript erhöht die Effizienz und Sicherheit der Verwaltung von macOS-Geräten erheblich. Für IT-Experten und MSPs ist dieses Skript ein wertvolles Instrument zur Aufrechterhaltung robuster Sicherheitsverfahren.

NinjaOne bietet umfassende Lösungen, die sich nahtlos in solche Skripte integrieren lassen und einen ganzheitlichen Ansatz für IT-Management und Sicherheit bieten. Durch den Einsatz von NinjaOne können Sie Ihre Arbeitsabläufe optimieren und sicherstellen, dass alle Ihre Geräte sicher sind und den Richtlinien Ihres Unternehmens entsprechen.