Come monitorare gli accessi degli utenti nei sistemi Windows con PowerShell

Punti di forza

• Monitoraggio automatico degli utenti: Questo script PowerShell automatizza il processo per monitorare gli accessi degli utenti degli accessi degli utenti sui sistemi Windows.
• Controlli personalizzabili: Personalizza lo script per monitorare gli accessi degli utenti per verificare la presenza di utenti specifici o di qualsiasi utente connesso.
• Integrazione con NinjaOne RMM: Si integra con NinjaOne RMM per una maggiore personalizzazione e per l’acquisizione dei dati.
• Efficienza operativa: Assicura che gli account utente necessari siano attivi per le funzionalità dell’applicazione.
• Miglioramento della sicurezza: Contribuisce a mantenere la sicurezza monitorando accessi autorizzati e non autorizzati.
• Flessibilità: Si adatta a diversi ambienti di runtime attraverso la gestione delle variabili d’ambiente.
• Avvisi in tempo reale: Fornisce avvisi immediati in base allo stato di accesso dell’utente.
• Compatibilità: Supporta Windows 10, Windows Server 2012 R2 e versioni successive.
• Facilità di integrazione: Può essere integrato con gli strumenti di gestione IT esistenti per un monitoraggio coeso del sistema.
• Supporto alla conformità: Contribuisce a garantire la conformità ai protocolli di sicurezza tenendo traccia delle attività degli utenti.

Background

Lo script fornito per monitorare gli accessi degli utenti è uno strumento PowerShell progettato per i professionisti IT e i Managed Service Provider (MSP) per monitorare gli accessi degli utenti sui sistemi basati su Windows. La sua importanza deriva dalla necessità di garantire che specifici account utente siano attivi o di verificare se un utente sia connesso, in particolare per le applicazioni legacy che richiedono sessioni utente autenticate. Lo script si distingue per le opzioni di personalizzazione e l’integrazione con NinjaOne RMM, la nostra piattaforma di monitoraggio e gestione da remoto.

Lo script per monitorare gli accessi degli utenti:

<#
.SYNOPSIS
    Alert if no user is logged in, or if a specified user is not logged in. It can also accept a custom text field name to identify the user to check.
.DESCRIPTION
    Alert if no user is logged in, or if a specified user is not logged in. It can also accept a custom text field name to identify the user to check.
    
    Intended for legacy apps that are non-functional without an actual user account signed in.
.EXAMPLE
    (No Parameters)
    itAdmin alternateAdmin tuser is currently signed in!

PARAMETER: -CheckUser "itAdmin"
    Enter in the user you'd like to alert on. ex. to alert on user itAdmin use -CheckUser "itAdmin"
.EXAMPLE
    -CheckUser "itAdmin"
    itAdmin is currently signed in!

PARAMETER: -CustomFieldName "ReplaceMeWithAnyTextCustomField"
    The name of a text custom field to grab the CheckUser value from.
.EXAMPLE
    -CustomFieldName "ReplaceMeWithAnyTextCustomField"
    itAdmin is currently signed in!

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2012 R2
    Release Notes: Renamed script and added Script Variable support
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/it/condizioni-utilizzo
    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()]
    [Switch]$ActiveOnly = [System.Convert]::ToBoolean($env:userMustBeActive),
    [Parameter()]
    [String]$CheckUser,
    [Parameter()]
    [String]$CustomFieldName
)

begin {
    # If script variables are used overwrite the existing variables.
    if ($env:userToCheckFor -and $env:userToCheckFor -notlike "null") { $CheckUser = $env:userToCheckFor }
    if ($env:retrieveUserFromCustomFieldName -and $env:retrieveUserFromCustomFieldName -notlike "null") { $CustomFieldName = $env:retrieveUserFromCustomFieldName }

    # This function is to make it easier to parse Ninja Custom Fields.
    function Get-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter()]
            [String]$DocumentName
        )

        if($PSVersionTable.PSVersion.Major -lt 3){
            throw "PowerShell 3.0 or higher is required to retrieve data from custom fields. https://ninjarmm.zendesk.com/hc/en-us/articles/4405408656013"
        }

        # If we're requested to get the field value from a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }

        # These two types require more information to parse.
        $NeedsOptions = "DropDown","MultiSelect"

        # Grabbing document values requires a slightly different command.
        if ($DocumentName) {
            # Secure fields are only readable when they're a device custom field
            if ($Type -Like "Secure") { throw "$Type is an invalid type! Please check here for valid types. https://ninjarmm.zendesk.com/hc/en-us/articles/16973443979789-Command-Line-Interface-CLI-Supported-Fields-and-Functionality" }

            # We'll redirect the error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
            Write-Host "Retrieving value from Ninja Document..."
            $NinjaPropertyValue = Ninja-Property-Docs-Get -AttributeName $Name @DocumentationParams 2>&1

            # Certain fields require more information to parse.
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            # We'll redirect error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
            $NinjaPropertyValue = Ninja-Property-Get -Name $Name 2>&1

            # Certain fields require more information to parse.
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }

        # If we received some sort of error it should have an exception property and we'll exit the function with that error information.
        if ($NinjaPropertyValue.Exception) { throw $NinjaPropertyValue }
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }

        # This switch will compare the type given with the quoted string. If it matches, it'll parse it further; otherwise, the default option will be selected.
        switch ($Type) {
            "Attachment" {
                # Attachments come in a JSON format this will convert it into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Checkbox" {
                # Checkbox's come in as a string representing an integer. We'll need to cast that string into an integer and then convert it to a more traditional boolean.
                [System.Convert]::ToBoolean([int]$NinjaPropertyValue)
            }
            "Date or Date Time" {
                # In Ninja Date and Date/Time fields are in Unix Epoch time in the UTC timezone the below should convert it into local time as a datetime object.
                $UnixTimeStamp = $NinjaPropertyValue
                $UTC = (Get-Date "1970-01-01 00:00:00").AddSeconds($UnixTimeStamp)
                $TimeZone = [TimeZoneInfo]::Local
                [TimeZoneInfo]::ConvertTimeFromUtc($UTC, $TimeZone)
            }
            "Decimal" {
                # In ninja decimals are strings that represent a decimal this will cast it into a double data type.
                [double]$NinjaPropertyValue
            }
            "Device Dropdown" {
                # Device Drop-Downs Fields come in a JSON format this will convert it into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Device MultiSelect" {
                # Device Multi-Select Fields come in a JSON format this will convert it into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Dropdown" {
                # Drop-Down custom fields come in as a comma-separated list of GUIDs; we'll compare these with all the options and return just the option values selected instead of a GUID.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Options | Where-Object { $_.GUID -eq $NinjaPropertyValue } | Select-Object -ExpandProperty Name
            }
            "Integer" {
                # Cast's the Ninja provided string into an integer.
                [int]$NinjaPropertyValue
            }
            "MultiSelect" {
                # Multi-Select custom fields come in as a comma-separated list of GUID's we'll compare these with all the options and return just the option values selected instead of a guid.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = ($NinjaPropertyValue -split ',').trim()

                foreach ($Item in $Selection) {
                    $Options | Where-Object { $_.GUID -eq $Item } | Select-Object -ExpandProperty Name
                }
            }
            "Organization Dropdown" {
                # Turns the Ninja provided JSON into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Organization Location Dropdown" {
                # Turns the Ninja provided JSON into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Organization Location MultiSelect" {
                # Turns the Ninja provided JSON into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Organization MultiSelect" {
                # Turns the Ninja provided JSON into a PowerShell Object.
                $NinjaPropertyValue | ConvertFrom-Json
            }
            "Time" {
                # Time fields are given as a number of seconds starting from midnight. This will convert it into a datetime object.
                $Seconds = $NinjaPropertyValue
                $UTC = ([timespan]::fromseconds($Seconds)).ToString("hh\:mm\:ss")
                $TimeZone = [TimeZoneInfo]::Local
                $ConvertedTime = [TimeZoneInfo]::ConvertTimeFromUtc($UTC, $TimeZone)

                Get-Date $ConvertedTime -DisplayHint Time
            }
            default {
                # If no type was given or not one that matches the above types just output what we retrieved.
                $NinjaPropertyValue
            }
        }
    }

    function Get-User {
        $quser = quser.exe
        $quser -replace '\s{2,}', ',' -replace '>' | ConvertFrom-Csv
    }

}process {

    # If a custom field name is provided grab the text and overwrite the $CheckUser variable with it.
    if ($CustomFieldName) { 
        if (-not ($CheckUser)) {
            try{
                $CheckUser = Get-NinjaProperty -Name $CustomFieldName
            }catch{
                Write-Warning "$($_.ToString())"
            }

            if(-not $CheckUser){
                Write-Warning "The custom field $CustomFieldName was empty!" 
            }
        }
    }

    if($CheckUser){
        Write-Host "Checking for $CheckUser."
    }else{
        Write-Host "Checking if any user is logged in."
    }

    # This will work whether or not your looking for any user to be logged in ($CheckUser = $null) or a specific one.
    $LoggedInUsers = Get-User
    if ($ActiveOnly) {
        $Test = $LoggedInUsers | Where-Object { $_.USERNAME -match $CheckUser } | Where-Object { $_.STATE -like "Active" }
    }
    else {
        $Test = $LoggedInUsers | Where-Object { $_.USERNAME -match $CheckUser } 
    }

    # If we didn't find the user or users we were looking for error out and exit 1
    if (!$Test) {
        Write-Error "The user(s) you are checking for is not currently logged in!"
        $LoggedInUsers | Format-Table USERNAME, STATE, "LOGON TIME", SESSIONNAME | Out-String | Write-Host
        exit 1
    }
    else {
        # Otherwise exit 0
        Write-Host "$($LoggedInUsers.USERNAME) is currently signed in!"
        $LoggedInUsers | Format-Table USERNAME, STATE, "LOGON TIME", SESSIONNAME | Out-String | Write-Host
        exit 0
    }
    
}end {
    
    
    
}

 

Analisi dettagliata

Lo script per monitorare gli accessi degli utenti opera in diverse fasi:

• Inizializzazione: Lo script per monitorare gli accessi degli utenti inizia impostando i parametri che controllano il suo comportamento, per esempio controllando solo gli utenti attivi o concentrandosi su un utente specifico.
• Gestione delle variabili d’ambiente: Controlla le variabili d’ambiente che potrebbero sovrascrivere i suoi parametri, garantendo l’adattabilità a diversi ambienti di esecuzione.
• Recupero di campi personalizzati: Lo script per monitorare gli accessi degli utenti può recuperare le informazioni dell’utente dai campi personalizzati definiti, offrendo flessibilità nell’acquisizione dei dati di accesso.
• Recupero dell’accesso utente: Utilizzando il comando quser, recupera l’elenco degli utenti connessi, una funzionalità centrale dello script.
• Controllo utenti e avvisi: A seconda dei parametri impostati, lo script per monitorare gli accessi degli utenti verifica la presenza di qualsiasi utente connesso o di un utente specifico e avvisa di conseguenza.

Casi d’uso potenziali

Immagina un amministratore IT responsabile di una rete in cui applicazioni specifiche richiedono che un utente amministratore sia costantemente connesso. Utilizzando questo script per monitorare gli accessi degli utenti, potrà impostare controlli automatici per garantire che gli account utente necessari siano attivi, mantenendo così la funzionalità dell’applicazione e la sicurezza del sistema.

Confronti

I metodi tradizionali di monitoraggio degli accessi degli utenti possono comportare controlli manuali o script di base senza opzioni di personalizzazione. Questo script PowerShell per monitorare gli accessi degli utenti supera questi metodi grazie all’integrazione con NinjaOne RMM, alla personalizzazione e alle funzionalità di avviso automatico.

Domande frequenti

D: In che modo questo script per monitorare gli accessi degli utenti migliora la sicurezza?
R: Assicurando che gli account utente necessari siano attivi e monitorando gli accessi non autorizzati.

D: Può essere personalizzato per monitorare utenti non amministratori?
R: Assolutamente sì, lo script per monitorare gli accessi degli utenti può essere personalizzato per monitorare qualsiasi account utente.

D: È compatibile con tutte le versioni di Windows?
R: Supporta Windows 10, Windows Server 2012 R2 e versioni successive.

Implicazioni

La capacità dello script di monitorare gli accessi degli utenti è fondamentale per mantenere i protocolli di sicurezza, garantire la conformità e prevenire gli accessi non autorizzati. Inoltre, lo script per monitorare gli accessi degli utenti aiuta nella risoluzione dei problemi e nella manutenzione operativa, fornendo i dati di accesso degli utenti in tempo reale.

Raccomandazioni

• Aggiorna regolarmente lo script per mantenerlo allineato agli aggiornamenti del sistema.
• Personalizza i parametri dello script in base alle esigenze specifiche dell’ambiente IT.
• Integra lo script con gli strumenti di gestione IT esistenti per un approccio di monitoraggio coeso.

Considerazioni finali

L’integrazione di questo script PowerShell nell’infrastruttura IT, soprattutto se combinato con NinjaOne, migliora la capacità di monitorare efficacemente gli accessi degli utenti. La piattaforma NinjaOne fornisce un ulteriore livello di gestione e sicurezza, rendendo lo script una parte importantissima di una strategia di gestione IT completa.