PowerShell-Skript-Handbuch: Gesperrte Konten in Windows aufspüren

Die wichtigsten Erkenntnisse

• PowerShell für mehr Effizienz: Nutzt PowerShell, um gesperrte Konten in Windows-Umgebungen schnell zu identifizieren.
• Ausgeschlossen ist Azure AD: Das Skript deckt keine Azure AD-Konten ab und konzentriert sich ausschließlich auf lokale und Domänencontroller-Konten.
• Umweltspezifische Erkennung: Der Ansatz hängt davon ab, ob er auf einem Domain Controller oder einer Workstation ausgeführt wird.
• Anpassbare Ausgabe: Bietet Flexibilität beim Ausgabeformat und ermöglicht den Export sowohl in CSV- als auch in TXT-Dateien.
• Fähigkeit zur Benutzerfilterung: Kann bei Bedarf bestimmte Nutzer ansprechen, was die Präzision erhöht.
• Automatisch statt manuell: Stellt eine effiziente Alternative zu manuellen Kontokontrollmethoden dar.
• Ein Hinweis auf größere Probleme: Gesperrte Konten können ein Zeichen für umfassendere Sicherheits- oder Betriebsprobleme sein.
• Zugänglich für Anfänger: Benutzerfreundlich für diejenigen mit grundlegenden PowerShell-Kenntnissen, aber dennoch anpassbar für fortgeschrittene Benutzer.
• Regelmäßige Überwachung empfohlen: Am besten als Teil einer regelmäßigen Kontoüberwachungsstrategie zu verwenden.
• Verbessert mit NinjaOne: Die Funktionalität des Skripts ergänzt die umfassenden IT-Management-Tools von NinjaOne.

In der sich ständig weiterentwickelnden Landschaft der IT-Sicherheit bleibt die Verwaltung von Benutzerkonten ein Eckpfeiler für den Schutz von Systemen und Daten. Ein wichtiger Aspekt ist die Überwachung und Behebung gesperrter Konten, ein häufiges Problem in großen und dynamischen IT-Umgebungen. Mit PowerShell können Administratoren gesperrte Konten effizient identifizieren und so Geschäftskontinuität und Sicherheit gewährleisten.

Hintergrund

Das mitgelieferte PowerShell-Skript erweist sich als unverzichtbares Tool für IT-Expert:innen und Managed Service Provider (MSPs). Seine Hauptfunktion besteht darin, gesperrte Konten in einer Windows-Umgebung zu identifizieren, ausgenommen Azure AD-Konten. Diese Fähigkeit ist entscheidend für die Aufrechterhaltung der betrieblichen Effizienz und Sicherheit, da gesperrte Konten sowohl ein Symptom für Benutzerfehler als auch ein potenzieller Indikator für Sicherheitsverletzungensein können .

Das Skript:

<#
.SYNOPSIS
    This script will see if any accounts on a local machine or on a domain controller are locked out. 
    You can optionally export this information into a custom field.

    Does NOT check Azure AD Accounts.
.DESCRIPTION
    This script will see if any accounts on a local machine or on a domain controller are locked out. 
    You can optionally export this information into a custom field.

    Does NOT check Azure AD Accounts.
    
.EXAMPLE
    (No Parameters but ran on a DC)
    SamAccountName LastLogonDate        PasswordExpired Enabled
    -------------- -------------        --------------- -------
    user           4/20/2023 1:09:23 PM           False    True

.EXAMPLE
    (No Parameters but ran on a Workstation)
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

PARAMETER: -ExportTXT "ReplaceMeWithAnyMultiLineCustomField"
    Name of a multi-line customfield you'd like to export the results to.
.EXAMPLE
    -ExportTXT "ReplaceMeWithAnyMultiLineCustomField"
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

PARAMETER: -ExportCSV "ReplaceMeWithAnyMultiLineCustomField"
    Name of a multi-line customfield you'd like to export the results to.
.EXAMPLE
    -ExportCSV "ReplaceMeWithAnyMultiLineCustomField"
    Name  Domain LocalAccount Disabled
    ----  ------ ------------ --------
    user  TEST          False    False

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2008
    Release Notes: Renamed script, added Script Variable support, added support for showing results of only 1 or more specific users.
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]$Users,
    [Parameter()]
    [String]$ExportCSV,
    [Parameter()]
    [String]$ExportTXT
)

begin {
    if ($env:usersToCheck -and $env:usersToCheck -notlike "null") { $Users = $env:usersToCheck }
    if ($env:exportCsvResultsToThisCustomField -and $env:exportCsvResultsToThisCustomField -notlike "null") { $ExportCSV = $env:exportCsvResultsToThisCustomField }
    if ($env:exportTextResultsToThisCustomField -and $env:exportTextResultsToThisCustomField -notlike "null") { $ExportTXT = $env:exportTextResultsToThisCustomField }

    if ($Users) {
        $UsersToCheck = $Users.split(',') | ForEach-Object { $_.Trim() }
        Write-Warning "Only the following users will be checked: $UsersToCheck"
    }
    function Test-IsDomainController {
        if ($PSVersionTable.PSVersion.Major -ge 5) {
            $OS = Get-CimInstance -ClassName Win32_OperatingSystem
        }
        else {
            $OS = Get-WmiObject -Class Win32_OperatingSystem
        }

        if ($OS.ProductType -eq "2") {
            return $True
        }
    }

    function Test-IsAzureJoined {
        $dsreg = dsregcmd.exe /status | Select-String "AzureAdJoined : YES"
        if ($dsreg) {
            return $True
        }
    }

    if ([System.Environment]::OSVersion.Version.Major -ge 10) {
        if (Test-IsAzureJoined) { Write-Warning "This device is Azure AD Joined, this script currently cannot detect if Azure AD Users are locked out!" }
    }
}
process {

    # For Domain Controllers find the locked out account using Search-ADAccount
    if (Test-IsDomainController) {
        Import-Module ActiveDirectory
        $LockedOutUsers = Search-ADAccount -LockedOut | Select-Object SamAccountName, LastLogonDate, PasswordExpired, Enabled
    }
    else {
        $LockedOutUsers = if ($PSVersionTable.PSVersion.Major -ge 5) {
            Get-CimInstance -ClassName Win32_Useraccount | Where-Object { $_.Lockout -eq $True } | Select-Object Name, Domain, LocalAccount, Disabled 
        }
        else {
            Get-WmiObject -Class Win32_Useraccount | Where-Object { $_.Lockout -eq $True } | Select-Object Name, Domain, LocalAccount, Disabled
        }
    }

    if ($Users) {
        $LockedOutUsers = $LockedOutUsers | Where-Object { $UsersToCheck -contains $_.Name -or $UsersToCheck -contains $_.SamAccountName } 
    }

    if ($LockedOutUsers) {
        # Output any locked out users into the activity log
        Write-Warning "Locked out users were found!"
        $LockedOutUsers | Format-Table | Out-String | Write-Host

        # Export the list in CSV format into a custom field
        if ($ExportCSV) {
            Ninja-Property-Set $ExportCSV ($LockedOutUsers | ConvertTo-Csv -NoTypeInformation)
        }

        # Export the usernames into a custom field
        if ($ExportTXT) {
            if ($LockedOutUsers.Name) {
                Ninja-Property-Set $ExportTXT ($LockedOutUsers.Name | Out-String)
            }

            if ($LockedOutUsers.SamAccountName) {
                Ninja-Property-Set $ExportTXT ($LockedOutUsers.SamAccountName | Out-String)
            }
        }
        Exit 1
    }

    Write-Host "No locked out users detected. Please note this does NOT check Azure AD Accounts."
    Exit 0
}
end {
    
    
    
}

 

Detaillierte Aufschlüsselung

Das Drehbuch funktioniert auf einfache, aber effektive Weise:

• Initialisierung der Parameter: Sie beginnt mit der Einstellung von Parametern für die Benutzereingabe, die Optionen für die Angabe bestimmter Benutzer und den Export von Ergebnissen im CSV- oder TXT-Format umfassen.
• Umweltchecks: Das Skript prüft dann die Betriebsumgebung und stellt fest, ob der Computer auf einem Domänencontroller oder einer Workstation läuft und ob er mit Azure AD verbunden ist. Dies ist von entscheidender Bedeutung, da es die Methode bestimmt, mit der gesperrte Konten gefunden werden.
• Erkennung von gesperrten Konten:
  • Auf Domänencontrollern verwendet es Search-ADAccount, um gesperrte Konten zu finden.
  • Auf Workstations werden die Methoden der Klasse Win32_UserAccount verwendet, um dasselbe zu erreichen.
• Selektive Benutzerüberprüfung: Wenn bestimmte Benutzer:innen angegeben werden, werden die Ergebnisse entsprechend gefiltert.
• Ausgabe und Exportieren: Das Skript zeigt gesperrte Konten an und bietet die Möglichkeit, diese Informationen im CSV- oder TXT-Format zu exportieren.
• Fertigstellung: Abschließend wird angegeben, ob gesperrte Konten entdeckt wurden oder nicht.

Mögliche Anwendungsfälle

Stellen Sie sich vor, ein MSP verwaltet ein Netzwerk mit zahlreichen Benutzerkonten. Plötzlich melden mehrere Benutzer:innen , dass sie nicht mehr auf ihre Konten zugreifen können. Der MSP kann dieses Skript schnell ausführen, um gesperrte Konten zu identifizieren, was den Prozess der Fehlersuche und -behebung erheblich beschleunigt.

Vergleiche

Traditionell werden gesperrte Konten manuell oder mit separaten Tools wie AD-Verwaltungstools überprüft. Der PowerShell-Ansatz optimiert diesen Prozess und bietet eine besser integrierte und skriptfähige Lösung, die für große Umgebungen effizient ist.

FAQs

• Kann dieses Skript Azure AD-Konten überprüfen?
  Nein, es ist speziell für lokale und Domänencontroller-Konten gedacht.
• Ist dieses Skript für Anfänger in PowerShell geeignet?
  Ja, es ist benutzerfreundlich, obwohl ein Grundverständnis von PowerShell empfohlen wird.
• Kann das Skript angepasst werden?
  Auf jeden Fall ist es flexibel und kann an die jeweiligen Anforderungen angepasst werden.

Auswirkungen

Das Skript ist zwar sehr effektiv, aber es ist wichtig, daran zu denken, dass gesperrte Konten auf tiefere Probleme hinweisen können, z. B. auf Sicherheitsverletzungen oder Systemmissbrauch. Die rechtzeitige Identifizierung und Analyse ist entscheidend.

Empfehlungen

• Verwenden Sie das Skript regelmäßig für proaktive Kontrollen.
• Kombinieren Sie dies mit umfassenderen Sicherheitsprotokollen.
• Passen Sie das Skript an Ihre spezifischen Umgebungsanforderungen an.

Abschließende Überlegungen

In einer Zeit, in der Effizienz und Sicherheit an erster Stelle stehen, bietet NinjaOne die Tools und Fähigkeiten, die für ein modernes IT-Managementnotwendig sind. Dieses Skript veranschaulicht, wie PowerShell, eine Komponente der NinjaOne-Suite, zur Verbesserung des IT-Betriebs und der Sicherheit eingesetzt werden kann. NinjaOnes umfassender Ansatz für das IT-Management macht es zu einem unverzichtbaren Verbündeten bei der Navigation durch die komplexe IT-Landschaft.