Automatizzare il rilevamento degli account inattivi con PowerShell

Punti chiave

• Protocollo di sicurezza automatizzato: Lo script automatizza il rilevamento degli account inattivi, migliorando la sicurezza.
• Soglia personalizzabile: Puoi regolare la soglia di inattività per allinearla ai criteri organizzativi.
• Compatibilità con più ambienti: In grado di gestire account locali, Active Directory e Azure AD.
• Efficienza in termini di tempo e risorse: Lo script per il rilevamento degli account inattivi automatizza quello che sarebbe un processo manuale che richiederebbe molto tempo.
• Gestione proattiva del rischio: Lo script per il rilevamento degli account inattivi aiuta a prevenire le violazioni della sicurezza gestendo le potenziali vulnerabilità.
• Trasparenza e flessibilità: Essendo uno script PowerShell, è trasparente e personalizzabile per esigenze specifiche.
• Audit programmati: Lo script per il rilevamento degli account inattivi può essere impostato per funzionare a intervalli regolari per un monitoraggio continuo.
• Reportistica completa: Lo script per il rilevamento degli account inattivi genera report dettagliati sui conti inattivi, aiutando il processo decisionale.
• Integrazione con gli strumenti di gestione: Lo script per il rilevamento degli account inattivi si completa e si integra con soluzioni di gestione IT come NinjaOne.

Nel panorama dinamico della gestione IT, la sicurezza e l’efficienza della gestione degli account utente rimangono fondamentali. Monitorare regolarmente gli account utente inattivi e affrontare le situazioni a essi correlate non è solo una best practice, ma una necessità per mantenere un ambiente IT sicuro. È qui che gli script PowerShell, come quello di cui parliamo oggi, diventano strumenti preziosi per i professionisti IT e i Managed Service Provider (MSP). 

Background

Lo script per il rilevamento degli account inattivi è progettato per identificare e avvisare gli amministratori degli account inattivi o inutilizzati in un ambiente Windows. Gli account inattivi possono rappresentare un rischio significativo per la sicurezza, in quanto, se compromessi, costituiscono potenziali punti di ingresso per accessi non autorizzati. Per i professionisti IT e gli MSP, questi script sono fondamentali per affrontare preventivamente le vulnerabilità della sicurezza e garantire la conformità ai criteri e alle normative.

Lo script per il rilevamento degli account inattivi:

<#
.SYNOPSIS
    Alerts when there is an inactive / unused account that has not logged in or has not had their password set in the specified number of days.
.DESCRIPTION
    Alerts when there is an inactive / unused account that has not logged in or has not had their password set in the specified number of days.
.EXAMPLE
    -IncludeDisabled
    
    Action completed: Run Monitor Account Last Logon Result: FAILURE Output: Action: Run Monitor Account Last Logon, Result: Failed
    WARNING: Inactive accounts detected!

    Username       PasswordLastSet       LastLogon              Enabled
    --------       ---------------       ---------              -------
    Administrator  4/12/2023 9:05:18 AM  11/28/2023 10:31:06 AM    True
    Guest                                12/31/1600 4:00:00 PM    False
    DefaultAccount                       12/31/1600 4:00:00 PM    False
    kbohlander     11/29/2023 1:49:51 PM 12/5/2023 1:09:43 PM      True
    tuser1         12/1/2023 5:59:58 PM  12/4/2023 9:34:32 AM      True
    krbtgt         11/27/2023 3:40:20 PM 12/31/1600 4:00:00 PM    False
    tuser2         12/4/2023 3:40:27 PM  12/31/1600 4:00:00 PM     True
.EXAMPLE
    -Days 60
    
    Action completed: Run Monitor Account Last Logon Result: FAILURE Output: Action: Run Monitor Account Last Logon, Result: Failed
    WARNING: Inactive accounts detected!

    Username       PasswordLastSet       LastLogon              Enabled
    --------       ---------------       ---------              -------
    Administrator  4/12/2023 9:05:18 AM  11/28/2023 10:31:06 AM    True
    kbohlander     11/29/2023 1:49:51 PM 12/5/2023 1:09:43 PM      True
    tuser1         12/1/2023 5:59:58 PM  12/4/2023 9:34:32 AM      True
    tuser2         12/4/2023 3:40:27 PM  12/31/1600 4:00:00 PM     True
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2012
    Exit code 1: Found users that haven't logged in over X days and are enabled.
    Exit code 2: Calling "net.exe user" or "Get-LocalUser" failed.
    Release Notes: Renamed script, added Script Variable support, improved ad support, removed requires statement.
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()]
    [int]$Days = 90,
    [Parameter()]
    [switch]$IncludeDisabled = [System.Convert]::ToBoolean($env:includeDisabled)
)

begin {
    # Use script variables if available.
    if ($env:days -and $env:days -notlike "null") {
        $Days = $env:Days
    }

    # Change negative days to the expected positive days
    if ($Days -lt 0) {
        $Days = 0 - $Days
    }

    # Date where an account is considered inactive.
    $InactivityCutOff = (Get-Date).AddDays(-$Days)

    function Test-IsDomainJoined {
        if ($PSVersionTable.PSVersion.Major -lt 5) {
            return $(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain
        }
        else {
            return $(Get-CimInstance -Class Win32_ComputerSystem).PartOfDomain
        }
    }

    function Test-IsDomainController {
        $OS = if ($PSVersionTable.PSVersion.Major -lt 5) {
            Get-WmiObject -Class Win32_OperatingSystem
        }
        else {
            Get-CimInstance -ClassName Win32_OperatingSystem
        }

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

    # We'll want to warn that we're unable to check the actual Azure AD account 
    # (it requires O365 credentials and a powershell module both of which are not supported by this script).
    function Test-IsAzureJoined {
        try {
            $dsreg = dsregcmd.exe /status | Select-String "AzureAdJoined : YES"
        }
        catch {
            return $False
        }
        if ($dsreg) { return $True }
    }

    # For Non-Domain Controllers we'll check net user for the information we need.
    function Get-NetAccountInfo {
        [CmdletBinding()]
        param(
            [Parameter()]
            [string]$User,
            [Parameter()]
            [switch]$Domain
        )
        process {
            # Get user info from net.exe user
            $netuser = if ($Domain) { net.exe user $user /Domain }else { net.exe user $user }

            $success = $netuser | Select-String 'The command completed successfully.'
            if (-not $success) {
                throw "Failed to retrieve account info for user $user!"
            }

            #Pre-formatted Object
            $Object = New-Object psobject -Property @{
                Username        = $User
                Name            = "$(($netuser | Select-String 'Full Name') -split '  ' | Select-Object -Last 1)".Trim()
                Enabled         = "$(($netuser | Select-String 'Account active') -split '  ' | Select-Object -Last 1)".Trim()
                LastLogon       = "$(($netuser | Select-String 'Last logon') -split '  ' | Select-Object -Last 1)".Trim()
                PasswordLastSet = "$(($netuser | Select-String 'Password last set') -split '  ' | Select-Object -Last 1)".Trim()
            }

            # Formatted object using PowerShell datatypes (for easier parsing later).
            New-Object psobject -Property @{
                Username        = $Object.Username
                Name            = $Object.Name
                Enabled         = if ($Object.Enabled -eq "Yes") { $True }elseif ($Object.Enabled -eq "No") { $False }else { $Object.Enabled }
                LastLogon       = try { Get-Date $Object.LastLogon }catch { $Object.LastLogon };
                PasswordLastSet = try { Get-Date $Object.PasswordLastSet }catch { $Object.PasswordLastSet }
            }
        }
    }
}
process {

    # If it's an azure joined machine we should warn that we're not checking any of the Azure AD Accounts.
    if (Test-IsAzureJoined) {
        Write-Warning -Message "This script is unable to check Azure AD accounts however this script will check the local accounts on this machine."
    }

    $Report = New-Object System.Collections.Generic.List[object]

    # Warn if ad accounts are not able to be checked.
    if (-not (Test-IsDomainController) -and (Test-IsDomainJoined) -and -not (Test-ComputerSecureChannel)) {
        Write-Warning "Domain is not reachable! We'll be unable to check active directory accounts!"
    }

    # There are two ways this script will check for an inactive account one of which uses the Active Directory PowerShell module which is only availalbe on Domain Controllers / machines with RSAT installed.
    if (-not (Test-IsDomainController)) {

        # Compile a list of users to check.
        $Users = if ($PSVersionTable.PSVersion.Major -lt 5) {
            Get-WmiObject -Class "win32_UserAccount"        
        }
        else {
            Get-CimInstance -Class "win32_UserAccount"
        }

        # Grab the account info using net user (which is slightly different if it's a domain account or not).
        $Accounts = foreach ($User in $Users) {
            if ($User.Domain -ne $env:COMPUTERNAME ) {
                Get-NetAccountInfo -User $User.Name -Domain
            }
            else {
                Get-NetAccountInfo -User $User.Name
            }
        }
    }
    else {
        # Older OS's need to have the module manually imported.
        try {
            Import-Module ActiveDirectory
        }
        catch {
            Write-Error -Message "[Error] Failed to import PowerShell Active Directory Module. Is RSAT installed?" -Category DeviceError -Exception (New-Object System.Exception)
        }

        # Compile a list of users with the relevant attributes
        $Users = Get-AdUser -Filter * -Properties SamAccountName, DisplayName, PasswordLastSet, lastLogonTimestamp, lastLogon, Enabled
        
        # Convert that into a more parseable object
        $Accounts = foreach ($User in $Users) {
            $LastLogon = [datetime]::FromFileTime($User.lastLogon)
            $LastLogonTimeStamp = [datetime]::FromFileTime($User.LastLogonTimestamp)
            New-Object psobject -Property @{
                Username        = $User.SamAccountName
                Name            = $User.DisplayName
                Enabled         = $User.Enabled
                LastLogon       = if ($LastLogon -gt $LastLogonTimeStamp) { $LastLogon }else { $LastLogonTimeStamp }
                PasswordLastSet = $User.PasswordLastSet
            }
        }
    }

    # Compile a list of accounts that could be considered inactive
    $InactiveAccounts = $Accounts | Where-Object { ($_.LastLogon -eq "Never" -or $_.LastLogon -lt $InactivityCutOff) -and $_.PasswordLastSet -lt $InactivityCutOff }

    # Filter out disabled accounts if we're asked to.
    if ($IncludeDisabled) {
        $InactiveAccounts | ForEach-Object { $Report.Add($_) }
    }
    else {
        $InactiveAccounts | Where-Object { $_.Enabled -notlike $False } | ForEach-Object { $Report.Add($_) }
    }

    # If no inactive accounts exit
    if (-not $Report) {
        Write-Host "No inactive accounts detected!"
        exit 0
    }

    Write-Warning "Inactive accounts detected!"
    $Report | Format-Table -AutoSize -Property Username, PasswordLastSet, LastLogon, Enabled | Out-String | Write-Host
    exit 1
}
end {
    
    
    
}

 

Analisi dettagliata dello script per il rilevamento degli account inattivi

Lo script per il rilevamento degli account inattivi opera in un processo a più fasi:

• Inizializzazione dei parametri: Lo script per il rilevamento degli account inattivi inizia definendo i parametri, tra cui il numero di giorni superato il quale si dovrà considerare un account inattivo e l’opzione per includere gli account disabilitati.
• Controlli ambientali: Lo script per il rilevamento degli account inattivi controlla se il computer è unito a un dominio, un controller di dominio o se è unito ad Azure AD. Determina l’ambito dei controlli dell’account: locale, Active Directory o Azure.
• Recupero del conto: Per i controller non di dominio, recupera le informazioni sugli account utilizzando net.exe user o le istanze WMI/CIM, mentre per i domain controller utilizza il modulo PowerShell di Active Directory.
• Valutazione dell’attività: La funzione principale consiste nel valutare gli account utente in base alle date dell’ultimo accesso e dell’impostazione della password rispetto alla soglia di inattività.
• Generazione di report: Gli account inattivi vengono inseriti in un report, con un’opzione per escludere eventualmente i conti disabilitati.
• Avvisi e codici di uscita: Lo script per il rilevamento degli account inattivi termina avvisando gli amministratori di eventuali account inattivi e uscendo con un codice che indica la presenza o meno di tali account.

Casi d’uso potenziali

Immagina uno scenario in cui un amministratore IT di una grande azienda utilizzi questo script per il rilevamento degli account inattivi per verificare regolarmente gli account utente. Potrebbe programmare l’esecuzione dello script per il rilevamento degli account inattivi con cadenza mensile, generando avvisi per gli account che non sono attivi da oltre 90 giorni. Ciò consente una gestione proattiva degli account utente, riducendo il rischio di violazioni della sicurezza dovute ad account inattivi.

Confronti

Esistono approcci alternativi, come gli audit manuali o l’utilizzo di strumenti di terze parti. Tuttavia, questo script PowerShell per il rilevamento degli account inattivi offre una soluzione più diretta, personalizzabile ed economica. A differenza dei controlli manuali, automatizza il processo, facendo risparmiare tempo e riducendo gli errori umani. Rispetto agli strumenti di terze parti, offre trasparenza e flessibilità, in quanto i professionisti IT possono modificare lo script per adattarlo alle loro esigenze specifiche.

Domande frequenti

D1: Lo script per il rilevamento degli account inattivi è in grado di distinguere i tipi di account utente?
R1: Sì, può distinguere tra account locali, Active Directory e Azure AD.

D2: È possibile programmare l’esecuzione automatica di questo script per il rilevamento degli account inattivi?
R2: Assolutamente sì, questo può essere fatto utilizzando l’Utilità di pianificazione delle attività di Windows o strumenti di automazione simili.

D3: Questo script per il rilevamento degli account inattivi gestisce gli account in un ambiente cloud?
R3: È stato progettato principalmente per gli account locali e Active Directory; gli account Azure AD richiedono moduli e credenziali aggiuntive.

Implicazioni

Le implicazioni dell’uso di questo script per il rilevamento degli account inattivi sono di vasta portata. Identificando gli account inattivi, si riduce in modo significativo la superficie di attacco per potenziali violazioni della sicurezza. Tuttavia, i professionisti IT devono gestire il risultato dello script per il rilevamento degli account inattivi in modo responsabile, assicurandosi che la disabilitazione o l’eliminazione degli account sia conforme ai criteri organizzativi e alle esigenze degli utenti.

Raccomandazioni

• Audit regolari: Pianifica l’esecuzione dello script per il rilevamento degli account inattivi a intervalli regolari.
• Personalizzazione: Adatta i parametri dello script per il rilevamento degli account inattivi ai criteri organizzativi.
• Azioni di follow-up: Stabilisci un protocollo per la gestione degli account inattivi.

Considerazioni finali

In conclusione, script come quello per il rilevamento degli account inattivi, se utilizzati in modo efficace, contribuiscono in modo significativo alla sicurezza e all’efficienza delle operazioni IT nel suo complesso. Sono complementari a soluzioni come NinjaOne, che fornisce strumenti di gestione IT completi, e aiutano gli amministratori a mantenere il controllo sui loro ambienti IT. La capacità di NinjaOne di integrarsi con gli script PowerShell ne aumenta l’utilità, ed è uno dei motivi per cui NinjaOne risulta essere una scelta ideale per la gestione proattiva dell’IT.