Wichtigste Erkenntnisse
- PowerShell-Effizienz: PowerShell wird verwendet, um lokale Benutzerkonten effizient zu erstellen und zu verwalten.
- Erweiterte Funktionen: Umfasst die Planung für die Aktivierung/Deaktivierung von Konten und das Hinzufügen von Benutzer:innen zu Verwaltungsgruppen.
- Automatisierte Sicherheit: Generiert automatisch sichere Passwörter und erhöht so die Sicherheit der Konten.
- Zeitmanagement: Spart Zeit bei der Verwaltung von Benutzerkonten, was besonders nützlich für MSPs ist.
- Anpassbares Skript: Ermöglicht die Anpassung durch benutzerdefinierte Parameter.
- Aufgabenplanung: Bietet die Möglichkeit, Aufgaben zu planen, um Konten zu bestimmten Zeiten zu aktivieren oder zu deaktivieren.
- Gruppenverwaltung: Ermöglicht das Hinzufügen von Benutzer:innen zu bestimmten Gruppen, einschließlich Administrator:innen.
- Anpassungsfähig für Massenerstellung: Es wurde zwar für einzelne Konten entwickelt, kann aber auch für die Massen-Benutzererstellung angepasst werden.
- Auswirkungen auf die Sicherheit: Betont die Notwendigkeit strenger Zugangskontrollen und regelmäßiger Überprüfungen.
- Kompatibilität mit NinjaOne: Kann für ein zentrales IT-Management in NinjaOne integriert werden.
In der heutigen digitalen Welt ist die effiziente Verwaltung von Benutzerkonten für IT-Expert:innen von entscheidender Bedeutung. PowerShell, eine leistungsstarke Skriptsprache und Befehlszeilen-Shell, bietet eine dynamische Möglichkeit, diese Aufgaben zu erledigen. In diesem Blogbeitrag wird ein PowerShell-Skript untersucht, das nicht nur lokale Benutzerkonten erstellt, sondern auch Optionen für die Zeitplanung und Gruppenverwaltung bietet. Das Skript stellt seinen Nutzen in verschiedenen IT-Umgebungen unter Beweis.
Kontext
Dieses PowerShell-Skript zeichnet sich durch seine Fähigkeit aus, lokale Benutzerkonten mit erweiterten Funktionen wie der Planung von Aktivierungs-/Deaktivierungsdaten und dem Hinzufügen von Benutzer:innen zur lokalen Administratorgruppe zu erstellen. Diese Funktionen sind vor allem für IT-Expert:innen und Managed Service Provider (MSPs) wichtig, die eine große Anzahl von Benutzerkonten verwalten und den rechtzeitigen und sicheren Zugriff auf Systeme gewährleisten müssen.
Das Skript
#Requires -Version 5.1
<#
.SYNOPSIS
Create a local user account with options to enable and disable at specific dates, and add to local admin group. Saves randomly generated password to a custom field.
.DESCRIPTION
You can specify when the account will be enabled and/or disabled.
You can have the account be added as a member of the local Administrators group.
PARAMETER: -UserNameToAdd "JohnTSmith" -Name "John T Smith"
Create use with the name JohnTSmith and display name of John T Smith.
.EXAMPLE
-UserNameToAdd "JohnTSmith" -Name "John T Smith"
## EXAMPLE OUTPUT ##
User JohnTSmith has been created successfully.
User JohnTSmith was added to the local Users group.
PARAMETER: -UserNameToAdd "JohnTSmith" -Name "John T Smith" -DateAndTimeToEnable "Monday, January 1, 2020 1:00:00 PM"
Create use with the name JohnTSmith and display name of John T Smith.
The user will start out disabled.
A scheduled task will be create to enable the user after "Monday, January 1, 2020 1:00:00 PM"
.EXAMPLE
-UserNameToAdd "JohnTSmith" -Name "John T Smith" -DateAndTimeToEnable "Monday, January 1, 2020 1:00:00 PM"
## EXAMPLE OUTPUT ##
User JohnTSmith has been created successfully.
User JohnTSmith was added to the local Users group.
Created Scheduled Task: Enable User JohnTSmith
User JohnTSmith will be able to login after Monday, January 1, 2020 1:00:00 PM.
PARAMETER: -UserNameToAdd "JohnTSmith" -Name "John T Smith" -DisableAfterDays 10
Create use with the name JohnTSmith and display name of John T Smith.
The user will be disabled after 10 days after the user's creation.
.EXAMPLE
-UserNameToAdd "JohnTSmith" -Name "John T Smith" -DisableAfterDays 10
## EXAMPLE OUTPUT ##
User JohnTSmith has been created successfully.
User JohnTSmith was added to the local Users group.
PARAMETER: -UserNameToAdd "JohnTSmith" -Name "John T Smith" -AddToLocalAdminGroup
Create use with the name JohnTSmith and display name of John T Smith.
User will be added as a member of the local Administrators group.
.EXAMPLE
-UserNameToAdd "JohnTSmith" -Name "John T Smith" -AddToLocalAdminGroup
## EXAMPLE OUTPUT ##
User JohnTSmith has been created successfully.
User JohnTSmith was added to the local Users group.
User JohnTSmith was added to the local Administrators group.
.OUTPUTS
None
.NOTES
Minimum OS Architecture Supported: Windows 10, Windows Server 2016
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).
#>
[CmdletBinding()]
param (
[Parameter()]
[String]$UserNameToAdd,
[Parameter()]
[String]$Name,
[Parameter()]
[String]$PasswordCustomField,
[Parameter()]
[int]$PasswordLength,
[Parameter()]
[DateTime]$DateAndTimeToEnable,
[Parameter()]
[int]$DisableAfterDays,
[Parameter()]
[Switch]$AddToLocalAdminGroup,
[Parameter()]
$PasswordOptions
)
begin {
function Test-IsElevated {
$id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
$p = New-Object System.Security.Principal.WindowsPrincipal($id)
$p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}
function New-SecurePassword {
[CmdletBinding()]
param (
[Parameter(Mandatory = $false)]
[int]$Length = 16,
[Parameter(Mandatory = $false)]
[bool]$IncludeSpecialCharacters = $true
)
# .NET class for generating cryptographically secure random numbers
$cryptoProvider = New-Object System.Security.Cryptography.RNGCryptoServiceProvider
$SpecialCharacters = if ($IncludeSpecialCharacters) { '!@#$%&-' }
$passwordChars = "abcdefghjknpqrstuvwxyzABCDEFGHIJKMNPQRSTUVWXYZ0123456789$SpecialCharacters"
$password = for ($i = 0; $i -lt $Length; $i++) {
$byte = [byte[]]::new(1)
$cryptoProvider.GetBytes($byte)
$charIndex = $byte[0] % $passwordChars.Length
$passwordChars[$charIndex]
}
return $password -join ''
}
function New-LocalUserFromNinja {
param(
[string]$Username,
[string]$Name,
[string]$PasswordCustomField,
[DateTime]$EnableDate,
[int]$DisableAfterDays,
[switch]$AddToLocalAdminGroup
)
# Generate a secure localUserPassword
$Password = New-SecurePassword -Length $PasswordLength -IncludeSpecialCharacters $true
if ($Username -and $Name) {
# Check if the user already exists
if (-not (Get-LocalUser -Name $Username -ErrorAction SilentlyContinue)) {
# Create new local user
$UserSplat = @{
Name = "$Username"
FullName = "$Name"
Password = ConvertTo-SecureString -String $($Password -join '') -AsPlainText -Force
Description = "User account created on $(Get-Date)"
PasswordNeverExpires = $false
}
if ($EnableDate -and $EnableDate -gt (Get-Date)) {
$UserSplat['Disabled'] = $true
}
if (-not $EnableDate -and $DisableAfterDays) {
$UserSplat['AccountExpires'] = $(Get-Date).AddDays($DisableAfterDays)
}
elseif ($DisableAfterDays) {
$UserSplat['AccountExpires'] = $(Get-Date $EnableDate).AddDays($DisableAfterDays)
}
if ($env:passwordOptions -like 'Password Never Expires' -or $PasswordOptions -like 'Password Never Expires') {
$UserSplat['PasswordNeverExpires'] = $true
}
New-LocalUser @UserSplat
if ($env:passwordOptions -like 'User Must Change Password' -or $PasswordOptions -like 'User Must Change Password') {
net.exe user $Username /logonpasswordchg:yes
}
# Write it to a secure custom field
if ((Get-LocalUser -Name $Username -ErrorAction SilentlyContinue)) {
Write-Host "User $Username has been created successfully."
if ($PasswordCustomField -like "null") {
Write-Host "CustomField not specified."
Write-Host "Password set to: $Password"
}
else {
Ninja-Property-Set -Name "$PasswordCustomField" -Value "$Password"
Write-Host "Password saved to $PasswordCustomField Custom Field."
}
}
else {
throw "Failed to create User $Username."
}
Add-LocalGroupMember -Group $(Get-LocalGroup -Name "Users") -Member $Username
Write-Host "User $UserName was added to the local Users group."
# If date to enable account is specified, disable account until then
if ($EnableDate) {
if ($EnableDate -gt (Get-Date)) {
# Schedule a job to enable the user at the specified date
$TaskSplat = @{
Description = "Ninja Automation Enable User $Username"
Action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -WindowStyle Hidden -Command & {Enable-LocalUser -Name `"$Username`"}"
Trigger = New-ScheduledTaskTrigger -Once -At $EnableDate
Principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount
}
try {
New-ScheduledTask @TaskSplat | Register-ScheduledTask -User "System" -TaskName "Enable User $Username" | Out-Null
if ($(Get-ScheduledTask -TaskName "Enable User $Username")) {
Write-Host "Created Scheduled Task: Enable User $Username"
}
else {
throw "Failed to find scheduled task with the name 'Enable User $Username'"
}
}
catch {
Write-Error $_
throw "Failed to create Enable User scheduled task."
}
Write-Host "User $Username will be able to login after $EnableDate."
}
}
else {
Write-Host "No Enable Date is Set, $UserName is able to login now."
}
# Add to local admin group if specified
if ($AddToLocalAdminGroup) {
Add-LocalGroupMember -Group $(Get-LocalGroup -Name "Administrators") -Member $Username
if (-not (Get-LocalGroupMember -Group $(Get-LocalGroup -Name "Administrators") -Member $Username)) {
throw "Failed to add user to local Administrators group."
}
Write-Host "User $UserName was added to the local Administrators group."
}
}
else {
Write-Host "User $Username already exists."
}
}
else {
throw "Username and Name are required to create a local account."
}
}
}
process {
if ($env:usernameToAdd -and $env:usernameToAdd -like "null") {
Write-Error "usernameToAdd($env:usernameToAdd) parameter is invalid."
exit 1
}
if ($env:name -and $env:name -like "null") {
Write-Error "name($env:name) parameter is invalid."
exit 1
}
if ($env:passwordCustomField -and $env:passwordCustomField -like "null") {
Write-Error "passwordCustomField($env:passwordCustomField) parameter is invalid."
exit 1
}
if (-not (Test-IsElevated)) {
Write-Error -Message "Access Denied. Please run with Administrator privileges."
exit 1
}
$params = @{
Username = if ($PSBoundParameters.ContainsKey("UserNameToAdd")) { $UserNameToAdd }else { $env:usernameToAdd }
Name = if ($PSBoundParameters.ContainsKey("Name")) { $Name }else { $env:name }
}
# Conditionally add EnableDate
if ($env:dateAndTimeToEnable -and $env:dateAndTimeToEnable -notlike "null") {
$params["EnableDate"] = Get-Date "$env:dateAndTimeToEnable"
}
elseif ($PSBoundParameters.ContainsKey("DateAndTimeToEnable") -and $DateAndTimeToEnable) {
$params["EnableDate"] = $DateAndTimeToEnable
}
# Conditionally add DisableAfterDays
if ($env:disableAfterDays -notlike "null") {
$params["DisableAfterDays"] = $env:disableAfterDays
}
elseif ($PSBoundParameters.ContainsKey("DisableAfterDays")) {
$params["DisableAfterDays"] = $DisableAfterDays
}
# Conditionally add AddToLocalAdminGroup
if ([Convert]::ToBoolean($env:addToLocalAdminGroup)) {
$params["AddToLocalAdminGroup"] = $true
}
elseif ($PSBoundParameters.ContainsKey("AddToLocalAdminGroup")) {
$params["AddToLocalAdminGroup"] = $AddToLocalAdminGroup
}
# Conditionally add AddToLocalAdminGroup
if ($env:passwordCustomField -notlike "null") {
$params["PasswordCustomField"] = $env:passwordCustomField
}
elseif ($env:passwordCustomField -like "null") {
Write-Error "passwordCustomField: is Required"
exit 1
}
elseif ($PSBoundParameters.ContainsKey("PasswordCustomField")) {
$params["PasswordCustomField"] = $PasswordCustomField
}
if ($env:passwordLength -notlike "null") {
$PasswordLength = $env:passwordLength
}
elseif (-not $passwordLength) {
$PasswordLength = 20
}
try {
New-LocalUserFromNinja @params
}
catch {
Write-Error $_
exit 1
}
}
end {
}
Greifen Sie auf über 300 Skripte im NinjaOne Dojo zu.
Detailansicht
Das Skript ist in mehrere Schlüsselabschnitte unterteilt, in denen eine bestimmte Aufgabe erfüllt wird:
- Definition der Parameter: Parameter wie UserNameToAdd, Name und DateAndTimeToEnable werden deklariert und ermöglichen die Anpassung der Benutzereingabe.
- Funktionen: Kritische Funktionen wie Test-IsElevated, New-SecurePassword und New-LocalUserFromNinja werden definiert. Test-IsElevated prüft auf Administratorrechte, New-SecurePassword generiert ein sicheres Passwort, und New-LocalUserFromNinja stellt die Kernfunktionalität der Benutzererstellung und -verwaltung dar.
- Erstellung und Verwaltung von Benutzer:innen: Das Skript prüft, ob der angegebene Benutzer existiert, erstellt einen neuen, wenn dies nicht der Fall ist, und legt Eigenschaften wie Passwort, Beschreibung und Ablauf des Kontos fest. Es verwaltet auch das Hinzufügen von Benutzer:innen zu Gruppen und plant Aufgaben für die Aktivierung/Deaktivierung von Konten.
Potenzielle Anwendungsfälle
Stellen Sie sich vor, ein MSP verwaltet die IT für ein Unternehmen mit temporärem Personal. Er kann dieses Skript verwenden, um die Kontoerstellung für neue Mitarbeiter:innen zu automatisieren, indem er bestimmte Aktivierungs- und Deaktivierungsdaten festlegt und so Zeit spart und manuelle Fehler vermeidet.
Vergleiche
Die Verwaltung von Benutzerkonten erfolgt traditionell mit manuellen Prozessen oder einfachen Skripten, denen fortgeschrittene Funktionen wie die Generierung sicherer Passwörter oder die geplante Aktivierung/Deaktivierung fehlen. Dieses Skript bietet einen ausgefeilteren, sichereren und zeitsparenderen Ansatz.
FAQs
- Kann dieses Skript die Massen-Benutzererstellung verarbeiten?
Es ist zwar für einzelne Konten konzipiert, kann aber mit Änderungen auch für die Massenerstellung angepasst werden. - Ist der Einsatz in sensiblen Umgebungen sicher?
Ja, es enthält Funktionen wie die sichere Passwortgenerierung.
Folgen
Die Verwendung eines solchen Skripts erhöht die Sicherheit und Effizienz, unterstreicht aber auch die Notwendigkeit strenger Zugangskontrollen und Überwachungen, da die automatische Erstellung von Konten ein potenzieller Vektor für unbefugten Zugang sein kann, wenn sie nicht ordnungsgemäß verwaltet wird.
Empfehlungen
Zu den Best Practices gehören die regelmäßige Überprüfung von Skripten, die Verwendung in Verbindung mit robusten Prüfungsrichtlinien und die Sicherstellung, dass nur befugtes Personal Zugriff auf das Skript und seine Funktionen hat.
Abschließende Überlegungen
Sie wissen nun, wie Sie ein neues lokales Benutzerkonto mit PowerShell erstellen können. Falls Sie Ihr System noch weiter optimieren wollen, ziehen Sie die Integration des Skripts in eine Endpunkt-Management-Plattform in Betracht, wie etwa NinjaOne. Diese Plattform, die für die Rationalisierung von IT-Managementaufgaben bekannt ist, kann solche Skripte ergänzen, indem sie eine zentrale und benutzerfreundliche Schnittstelle für die Verwaltung dieser automatisierten Prozesse bietet. Die Integration von PowerShell-Skripten in eine NinjaOne-Umgebung kann die betriebliche Effizienz und Sicherheit der IT-Verwaltung erheblich verbessern.