Comment détecter le temps d’inactivité d’un utilisateur à l’aide de PowerShell

La détection des temps d’inactivité sur les ordinateurs est un aspect crucial pour les professionnels de l’informatique, en particulier face à l’augmentation des menaces de cybersécurité et aux problèmes de gestion des ressources. Les entreprises sont de plus en plus numérisées et les utilisateurs restent souvent connectés pendant de longues périodes. Il est donc primordial de détecter les temps d’inactivité des utilisateurs pour des raisons de sécurité et de fonctionnement. Dans cet article, nous allons nous plonger dans un script PowerShell conçu pour détecter le temps d’inactivité des utilisateurs le plus long, ce qui rend la tâche simple et efficace.

Contexte

La possibilité de déterminer le temps d’inactivité d’un utilisateur peut fournir des informations précieuses aux professionnels de l’informatique et aux fournisseurs de services gérés (MSP). Qu’il s’agisse de libérer des ressources, de s’assurer que les sessions ne restent pas exposées à des menaces de sécurité potentielles, ou même de prendre en compte les aspects liés à la facturation pour les fournisseurs de services cloud, il est essentiel de disposer d’une méthode efficace et fiable pour déterminer l’inactivité de l’utilisateur. Ce script particulier exploite les prouesses de PowerShell pour interagir directement avec le système d’exploitation Windows et extraire des données pertinentes pour évaluer les temps d’inactivité.

Le script

#Requires -Version 5.1

<#
.SYNOPSIS
    Returns the longest idle time of any user logged in or for a specific user.
.DESCRIPTION
    Returns the longest idle time of any user logged in or for a specific user.
    If RDS(Remote Desktop Services) is installed and the RSAT tools for it as well,
     then this will get the idle time of each logged in user.
    For workstations and servers(with out RDS installed),
     this will get the current idle of the currently logged in user.
    If a user is logged in via the console and another is via the admin RDP session,
     then both will be considered as one user for calculating idle time.
.EXAMPLE
    No parameters needed.
    Returns the longest idle time of all users logged in.
.EXAMPLE
     -UserName "Fred"
    Returns the longest idle time of the user Fred.
.EXAMPLE
    PS C:> Get-User-Idle-Time.ps1 -UserName "Fred"
    Returns the longest idle time of the user Fred.
.OUTPUTS
    PSCustomObject[]
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes:
    Adds functions to get idle time from RDS and non-RDS computers.
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 (
    # Specify one user on a Terminal Services Server, else leave blank for normal servers and workstations
    [Parameter(Mandatory = $false)]
    $UserName
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
        { Write-Output $true }
        else
        { Write-Output $false }
    }
    Function Get-QueryUser() {
        Param()
        $Result = @()
        # Replaces all occurrences of 2 or more spaces in a row with a single comma
        $Lines = @(query.exe user).foreach({ $(($_) -replace ('s{2,}', ',')) })
        if ($Lines.Count -gt 1) {
            $Header = $($Lines[0].split(',').trim())
            for ($i = 1; $i -lt $($Lines.Count); $i++) {
                $Res = "" | Select-Object $Header
                $Line = $($Lines[$i].split(',')).foreach({ $_.trim().trim('>') })
                # Accounts for disconnected users
                if ($Line.count -eq 5) {
                    $Line = @($Line[0], "$($null)", $Line[1], $Line[2], $Line[3], $Line[4] )
                }
                for ($j = 0; $j -lt $($Line.count); $j++) {
                    $Res.$($Header[$j]) = $Line[$j]
                }
                $Result += $Res
                Remove-Variable Res
            }
            return $Result
        }
        else {
            return $null
        }
    }

    Add-Type @"
using System;
using System.Runtime.InteropServices;
using System.ComponentModel;

namespace GetLastUserInput
{
    public class GetLastUserInput
    {
        private struct LASTINPUTINFO
        {
            public uint cbSize;
            public uint dwTime;
        }
        private static LASTINPUTINFO lastInPutNfo;
        static GetLastUserInput()
        {
            lastInPutNfo = new LASTINPUTINFO();
            lastInPutNfo.cbSize = (uint)Marshal.SizeOf(lastInPutNfo);
        }
        [DllImport("User32.dll")]
        private static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);

        /// <summary>
        /// Idle time in ticks
        /// </summary>
        /// <returns></returns>
        public static uint GetIdleTickCount()
        {
            return ((uint)Environment.TickCount - GetLastInputTime());
        }
        /// <summary>
        /// Last input time in ticks
        /// </summary>
        /// <returns></returns>
        public static uint GetLastInputTime()
        {
            if (!GetLastInputInfo(ref lastInPutNfo))
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
            return lastInPutNfo.dwTime;
        }
    }
}
"@
}

process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    if ($(Get-Module -Name "RemoteDesktop") -and $(Get-RDServer -ErrorAction SilentlyContinue)) {
        try {
            $Sessions = Get-RDUserSession
            $Sessions | Select-Object UserName, IdleTime
        }
        catch {
            Write-Warning -Message "A Remote Desktop Services deployment does not exist on $env:COMPUTERNAME."
        }
    }
    else {
        Write-Warning -Message "Remote Desktop Services is not installed on this computer, Falling back to query user."
        $Results = Get-QueryUser
        if ($null -eq $Results) {
            Write-Host "No user(s) logged in."
            exit 0
        }
        # Parse query results and loop through each user
        $Results | ForEach-Object {
            $CurrentUser = $_.USERNAME
            # If UserName param is used, only filter that user; If UserName param isn't used, return all users
            if ($CurrentUser -like $UserName -or ([string]::IsNullOrEmpty($UserName) -or [string]::IsNullOrWhiteSpace($UserName))) {
                # Output a PowerShell Custom Object array
                [PSCustomObject]@{
                    UserName    = $CurrentUser
                    SessionName = $_.SESSIONNAME
                    Id          = $_.ID
                    State       = $_.STATE
                    LogonTime   = $_.'LOGON TIME'
                    IdleTime    = if ($_.'IDLE TIME' -like 'none') { 0 }else { $_.'IDLE TIME' }
                }
            }
        } | Sort-Object -Property IdleTime | Select-Object -Property UserName, @{
            # Modify IdleTime when it shows none
            Label      = "IdleTime"
            Expression = {
                New-TimeSpan -Start $(Get-Date) -End $(Get-Date).AddMilliseconds([GetLastUserInput.GetLastUserInput]::GetIdleTickCount())
            }
        }
    }
}

end {}

 

Description détaillée

• CmdletBinding et paramètres : Le script commence par un CmdletBinding, ce qui permet de l’utiliser comme cmdlet. Il contient un paramètre facultatif pour désigner un nom d’utilisateur spécifique.
• Fonctions intérieures :
• Test-IsElevated vérifie si le script s’exécute avec des droits d’administrateur.
• Get-QueryUser s’interface avec query.exe pour obtenir des informations sur les utilisateurs actuels.
• Intégration d’une bibliothèque externe : Une bibliothèque externe (GetLastUserInput) est utilisée pour obtenir le temps d’inactivité.
• Bloc de processus : La logique de base est la suivante.
• Tout d’abord, il vérifie si le script s’exécute avec des droits d’administrateur.
• Si le RDS (Remote Desktop Services) est installé, il récupère le temps d’inactivité de chaque utilisateur connecté.
• Si le RDS n’est pas présent, il revient à l’approche d’interrogation de l’utilisateur et calcule le temps d’inactivité sur la base de la dernière entrée de l’utilisateur.

Cas d’utilisation potentiels

Imaginez que vous êtes administrateur informatique dans une entreprise de taille moyenne. Vous avez remarqué que de nombreux utilisateurs laissent leur poste de travail allumé et connecté, même après les heures de bureau. Il s’agit non seulement d’un risque pour la sécurité, mais aussi d’un coût de ressources du réseau et de l’alimentation électrique. En déployant ce script à l’échelle de l’entreprise, vous pouvez rapidement déterminer quels utilisateurs travaillent activement et quels postes de travail sont restés inactifs. Grâce à ces informations, vous pouvez appliquer des politiques de déconnexion automatique ou envoyer des rappels aux utilisateurs pour qu’ils éteignent leur machine.

Comparaisons

Bien qu’il existe des outils tiers qui détectent les temps d’inactivité, ils s’accompagnent souvent d’un surcroît de travail ou n’offrent pas assez de précision. Certains opteront pour l’interrogation du journal des événements de Windows à la recherche d’événements spécifiques, mais cette approche risque de ne pas tenir compte d’éléments tels qu’une vidéo en cours d’exécution qui maintient la session active. Ce script propose une méthode directe et personnalisable, qui s’appuie sur les outils et les commandes natives de Windows.

FAQ

• Le RDS est-il nécessaire pour ce script ?
  Non, il est conçu pour détecter les temps d’inactivité avec et sans RDS.
• Quelle est la précision du calcul des temps d’inactivité ?
  Sa précision correspond au nombre de ticks du système depuis la dernière action de l’utilisateur.

Implications

La détection des temps d’inactivité n’est pas seulement une question de gestion des ressources. Une session ouverte et inactive peut constituer une vulnérabilité. Les personnes malveillantes, une fois entrées dans le réseau, peuvent détourner ces sessions. La détection en temps utile et la gestion des sessions sont donc cruciales pour la sécurité informatique.

Recommandations

• Pour obtenir des résultats précis, exécutez toujours le script avec des droits d’administrateur.
• Mettez à jour régulièrement le script pour tenir compte des changements dans votre environnement Windows.
• Intégrez des outils de surveillance pour obtenir des alertes en temps réel sur les temps d’inactivité de longue durée.

Conclusions

En ce qui concerne la gestion des sessions d’utilisateurs inactifs, des outils comme NinjaOne peuvent encore amplifier l’efficacité en fournissant une plateforme unifiée pour surveiller, alerter et gérer. Qu’il s’agisse d’optimiser les ressources ou de renforcer le périmètre de sécurité, la compréhension des comportements des utilisateurs pendant les temps d’inactivité peut changer la donne. L’utilisation de scripts tels que celui-ci peut constituer le pilier de cette initiative, en particulier lorsqu’ils sont associés à des solutions de gestion informatique complètes.