Comment surveiller la dernière connexion d’un utilisateur avec PowerShell

Aujourd’hui, nous nous penchons sur un script PowerShell qui permet de surveiller la dernière connexion d’un utilisateur. Dans la gestion moderne de l’informatique, l’une des tâches essentielles consiste à surveiller les comptes d’utilisateurs, en particulier à identifier les comptes dormants. Cette tâche ne se limite pas à la maintenance habituelle. Elle est directement liée à la sécurité, à la conformité et à la gestion efficace des ressources.

Contexte

Le script fourni est conçu pour identifier et signaler les comptes d’utilisateurs en fonction de leur dernière heure de connexion, en particulier ceux qui n’ont pas été utilisés pendant une durée déterminée. Pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP), il est essentiel de s’assurer que les comptes inutilisés sont identifiés et gérés. Les comptes dormants présentent des risques pour la sécurité et deviennent souvent des cibles faciles pour les cybercriminels. De plus, les entreprises soumises à des règles de conformité sont tenues de suivre l’activité des utilisateurs et de désactiver les comptes inutilisés.

Le script

#Requires -Version 5.1

<#
.SYNOPSIS
    Returns exit code of 1 if any Enabled accounts that haven't been logged in over 90 days or a custom amount of days.
.DESCRIPTION
    Returns exit code of 1 if any Enabled accounts that haven't been logged in over 90 days or a custom amount of days.
.EXAMPLE
    No parameters needed.
    Returns exit code of 1 if any Enabled accounts that haven't been logged in over 90 days.
.EXAMPLE
    -IncludeDisabled
    Returns exit code of 1 if any Enabled or Disabled accounts that haven't been logged in over 90 days.
.EXAMPLE
    -Days 60
    Returns exit code of 1 if any Enabled accounts that haven't been logged in over 60 days.
.EXAMPLE
    -Days 60 -IncludeDisabled
    Returns exit code of 1 if any Enabled or Disabled accounts that haven't been logged in over 60 days.
.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:
    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).
.COMPONENT
    ManageUsers
#>

[CmdletBinding()]
param (
    [Parameter()]
    [int]
    $Days = 90,
    [Parameter()]
    [switch]
    $IncludeDisabled
)

begin {}
process {
    if ($Days -lt 0) {
        # Change negative days to the expected positive days
        $Days = 0 - $Days
    }
    $Accounts = if ($(Get-Command "Get-LocalUser").Name -like "Get-LocalUser") {
        try {
            Get-LocalUser | Select-Object Name, Enabled, SID, LastLogon
        }
        catch {
            exit 2
        }
    }
    else {
        # Get users from net.exe user
        $Data = $(net.exe user) | Select-Object -Skip 4
        # Check if the command ran the way we wanted and the exit code is 0
        if ($($Data | Select-Object -Last 2 | Select-Object -First 1) -like "*The command completed successfully.*" -and $LASTEXITCODE -eq 0) {
            # Process the output and get only the users
            $Users = $Data[0..($Data.Count - 3)] -split 's+' | Where-Object { -not $([String]::IsNullOrEmpty($_)) }
            # Loop through each user
            $Users | ForEach-Object {
                # Get the Account active property look for a Yes
                $Enabled = $(net.exe user $_) | Where-Object {
                    $_ -like "Account active*" -and
                    $($_ -split 's+' | Select-Object -Last 1) -like "Yes"
                }
                # Get the Last logon property
                $LastLogon = $(
                    $(
                        $(net.exe user $_) | Where-Object {
                            $_ -like "Last logon*"
                        }
                    ) -split 's+' | Select-Object -Skip 2
                ) -join ' '
                # Get the Password last set property
                $PasswordLastSet = $(
                    $(
                        $(net.exe user $_) | Where-Object {
                            $_ -like "Password last set*"
                        }
                    ) -split 's+' | Select-Object -Skip 3
                ) -join ' '
                # Output Name and Enabled almost like how Get-LocalUser displays it's data
                [PSCustomObject]@{
                    Name      = $_
                    Enabled   = if ($Enabled -like "*Yes*") { $true }else { $false }
                    LastLogon = if ($LastLogon -like "*Never*") { [DateTime]::Parse($PasswordLastSet) } else { [DateTime]::Parse($LastLogon) }
                }
            }
        }
        else {
            exit 2
        }
    }
    $Output = $Accounts | Where-Object {
        if ($IncludeDisabled) {
            $_.LastLogon -lt $(Get-Date).AddDays(0 - $Days)
        }
        else {
            $_.Enabled -and $_.LastLogon -lt $(Get-Date).AddDays(0 - $Days)
        }
    }
    $Output | Out-String | Write-Host
    if ($null -ne $Output) {
        exit 1
    }
}
end {}

 

Description détaillée

Le script commence par définir une durée par défaut de 90 jours pour vérifier l’inactivité. Il utilise ensuite la cmdlet « Get-LocalUser » ou la commande « net.exe user », en fonction de ce qui est disponible.

• Si la cmdlet « Get-LocalUser » est présente, elle récupère directement les détails.
• Si ce n’est pas le cas, il recourt à la commande « net.exe user ». Cette commande récupère les données et analyse ensuite les résultats pour en extraire les détails nécessaires.

La première démarche consiste à vérifier si la dernière date de connexion de chaque utilisateur est supérieure au seuil défini. Si une correspondance est trouvée, elle est affichée et le script se termine avec un code de 1. Un code de sortie de 2 est utilisé pour les exceptions lors de l’extraction des données de l’utilisateur.

Cas d’utilisation potentiels

Imaginez Jane, informaticienne dans une entreprise de taille moyenne. Récemment, l’entreprise a été confrontée à une faille de sécurité mineure. Après l’incident, Jane a été chargée de renforcer la sécurité. L’une des suggestions était de vérifier régulièrement les comptes inactifs et de les désactiver. À l’aide de ce script, elle peut mettre en place une routine mensuelle pour récupérer une liste de ces comptes, garantissant ainsi que le répertoire des utilisateurs de l’entreprise reste actif et sécurisé.

Comparaisons

Bien que le script utilise PowerShell, une autre approche pourrait consister à interroger directement l’Active Directory (s’il est disponible) pour obtenir des informations sur les comptes d’utilisateurs. Des outils comme ADManager Plus ou même Active Directory Users and Computers (ADUC) peuvent être utilisés. Cependant, notre script offre une alternative légère, personnalisable et gratuite.

FAQ

• Que faire si je veux vérifier une durée d’inactivité différente ?
  Vous pouvez personnaliser le paramètre $Days.

• Le script peut-il identifier les comptes activés et désactivés ?
  Oui, en utilisant l’option -IncludeDisabled, le script peut récupérer les comptes activés et désactivés.

Implications

Au-delà de l’identification des comptes dormants, ce script a un impact plus vaste sur la sécurité informatique. Les comptes inactifs peuvent être facilement compromis et donner lieu à un accès non autorisé. Des contrôles périodiques de l’inactivité des utilisateurs et des mesures appropriées peuvent prévenir les violations potentielles.

Recommandations

• Testez toujours le script dans un environnement bac à sable (sandbox) avant de le déployer dans un environnement réel.
• Planifiez l’exécution périodique de ce script afin d’assurer une surveillance continue.
• En cas d’identification de comptes dormants, prenez les mesures appropriées, telles que la désactivation du compte ou la notification à l’utilisateur ou à son responsable.

Conclusion

Tandis que ce script constitue une solution efficace, l’intégration d’outils tels que NinjaOne permet d’améliorer encore les capacités, en rendant les tâches plus automatisées et en fournissant un tableau de bord centralisé pour la gestion. Des outils tels que NinjaOne sont conçus pour gérer efficacement ces tâches, ce qui permet aux professionnels de l’informatique comme Jane de se concentrer sur des tâches plus stratégiques, en utilisant des scripts tels que celui présenté ci-dessus.