La gestion des comptes utilisateur est une responsabilité fondamentale pour les administrateurs informatiques. Les comptes utilisateur orphelins, qui ne sont plus associés à un utilisateur actif, présentent des risques tels qu’une utilisation inutile des ressources, des fuites de données potentielles et des vulnérabilités en matière de sécurité. Le script PowerShell analysé ici propose une approche automatisée pour identifier et gérer efficacement ces comptes.
Contexte
Dans les environnements multi-utilisateurs, en particulier dans les entreprises ou celles gérées par des fournisseurs de services gérés (MSP), les comptes utilisateur sont souvent oubliés lorsque les employés partent, changent de rôle ou que les systèmes sont restructurés. Ces profils orphelins s’accumulent dans le système, occupant un espace disque précieux et exposant potentiellement des informations sensibles. Ce script détecte non seulement les profils orphelins, mais fournit également des rapports détaillés, aidant ainsi les professionnels de l’informatique à maintenir leurs systèmes propres et sécurisés.
Le script :
#Requires -Version 5.1
<#
.SYNOPSIS
Looks for user profile folders that do not have an associated user account.
.DESCRIPTION
Looks for user profile folders that do not have an associated user account.
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).
.EXAMPLE
(No Parameters)
[Alert] Orphaned profiles found!
Username Size Path SID
-------- ---- ---- ---
UNKNOWN 554.97 MB C:\Users\tuser1 S-1-5-21-1255570301-2732419320-3119746845-1104
UNKNOWN 86.74 MB C:\Users\tuser22 S-1-5-21-3797121902-2219393589-2867574441-1001
PARAMETER: -CustomField "ReplaceMeWithTheNameOfaWYSIWYGcustomField"
Specify the name of an optional WYSIWYG Custom Field to save the results in.
.NOTES
Minimum OS Architecture Supported: Windows 10, Windows Server 2016
Release Notes: Initial Release
#>
[CmdletBinding()]
param (
[Parameter()]
[String[]]$DirectoriesToIgnore = ("All Users", "Default", "Default User", "Public"),
[Parameter()]
[String]$CustomField
)
begin {
# Set parameters using dynamic script variables.
if ($env:wysiwygCustomFieldName -and $env:wysiwygCustomFieldName -notlike "null") {
$CustomField = $env:wysiwygCustomFieldName
}
# Function to convert a size in bytes to a more human-readable format
function Get-FriendlySize {
param($Bytes)
# Array of size units
$Sizes = 'Bytes,KB,MB,GB,TB,PB,EB,ZB' -split ','
# Loop to find the appropriate size unit
for ($i = 0; ($Bytes -ge 1kb) -and ($i -lt $Sizes.Count); $i++) { $Bytes /= 1kb }
# Number of decimal places to show
$decimalPlaces = 2
# If the size is in bytes, no decimal places are needed
if ($i -eq 0) { $decimalPlaces = 0 }
# Return the rounded size with the appropriate unit
if ($Bytes) { "$([System.Math]::Round($Bytes,$decimalPlaces)) $($Sizes[$i])" }else { "0 B" }
}
# Function to retrieve user profile hives from the registry
function Get-UserHives {
param (
[Parameter()]
[ValidateSet('AzureAD', 'DomainAndLocal', 'All')]
[String]$Type = "All",
[Parameter()]
[String[]]$ExcludedUsers,
[Parameter()]
[switch]$IncludeDefault
)
# Define patterns to match user SIDs based on the Type parameter
$Patterns = switch ($Type) {
"AzureAD" { "S-1-12-1-(\d+-?){4}$" }
"DomainAndLocal" { "S-1-5-21-(\d+-?){4}$" }
"All" { "S-1-12-1-(\d+-?){4}$" ; "S-1-5-21-(\d+-?){4}$" }
}
# Retrieve user profiles from the registry
$UserProfiles = Foreach ($Pattern in $Patterns) {
Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\*" |
Where-Object { $_.PSChildName -match $Pattern } |
Select-Object @{Name = "SID"; Expression = { $_.PSChildName } },
@{Name = "Username"; Expression = { "$($_.ProfileImagePath | Split-Path -Leaf)" } },
@{Name = "UserHive"; Expression = { "$($_.ProfileImagePath)\NTuser.dat" } },
@{Name = "Path"; Expression = { $_.ProfileImagePath } },
@{Name = "Size"; Expression = { $(Get-ChildItem -Path $_.ProfileImagePath -Recurse -Force -ErrorAction SilentlyContinue | Measure-Object -Sum Length -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Sum -ErrorAction SilentlyContinue) } }
}
# Include the default profile if specified
switch ($IncludeDefault) {
$True {
$DefaultProfile = "" | Select-Object Username, SID, UserHive, Path
$DefaultProfile.Username = "Default"
$DefaultProfile.SID = "DefaultProfile"
$DefaultProfile.Userhive = "$env:SystemDrive\Users\Default\NTUSER.DAT"
$DefaultProfile.Path = "C:\Users\Default"
$DefaultProfile | Where-Object { $ExcludedUsers -notcontains $_.Username }
}
}
# Iterate over the user profiles to resolve user names from SIDs
$UserProfiles | ForEach-Object {
$SidObject = $Null
$NewUsername = $Null
# Convert SID to user name
if ($_.SID) {
try {
$SidObject = New-Object System.Security.Principal.SecurityIdentifier($_.SID)
$NewUsername = $SidObject.Translate([System.Security.Principal.NTAccount])
}
catch {
$NewUsername = $Null
}
}
# Assign the resolved user name or "UNKNOWN" if resolution fails
if ($NewUsername.Value) {
$_.Username = $NewUsername.Value
}
else {
$_.Username = "UNKNOWN"
}
}
$UserProfiles | Where-Object { $ExcludedUsers -notcontains $_.Username }
}
function Set-NinjaProperty {
[CmdletBinding()]
Param(
[Parameter(Mandatory = $True)]
[String]$Name,
[Parameter()]
[String]$Type,
[Parameter(Mandatory = $True, ValueFromPipeline = $True)]
$Value,
[Parameter()]
[String]$DocumentName
)
$Characters = $Value | Out-String | Measure-Object -Character | Select-Object -ExpandProperty Characters
if ($Characters -ge 200000) {
throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded: the value is greater than or equal to 200,000 characters.")
}
# If requested to set the field value for a Ninja document, specify it here.
$DocumentationParams = @{}
if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
# This is a list of valid fields that can be set. If no type is specified, assume that the input does not need to be changed.
$ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
if ($Type -and $ValidFields -notcontains $Type) { Write-Warning "$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" }
# The field below requires additional information to set.
$NeedsOptions = "Dropdown"
if ($DocumentName) {
if ($NeedsOptions -contains $Type) {
# Redirect error output to the success stream to handle errors more easily if nothing is found or something else goes wrong.
$NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
}
}
else {
if ($NeedsOptions -contains $Type) {
$NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
}
}
# If an error is received with an exception property, exit the function with that error information.
if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
# The types below require values not typically given to be set. The code below will convert whatever we're given into a format ninjarmm-cli supports.
switch ($Type) {
"Checkbox" {
# Although it's highly likely we were given a value like "True" or a boolean data type, it's better to be safe than sorry.
$NinjaValue = [System.Convert]::ToBoolean($Value)
}
"Date or Date Time" {
# Ninjarmm-cli expects the GUID of the option to be selected. Therefore, match the given value with a GUID.
$Date = (Get-Date $Value).ToUniversalTime()
$TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
$NinjaValue = $TimeSpan.TotalSeconds
}
"Dropdown" {
# Ninjarmm-cli expects the GUID of the option we're trying to select, so match the value we were given with a GUID.
$Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
$Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
if (-not $Selection) {
throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown options.")
}
$NinjaValue = $Selection
}
default {
# All the other types shouldn't require additional work on the input.
$NinjaValue = $Value
}
}
# Set the field differently depending on whether it's a field in a Ninja Document or not.
if ($DocumentName) {
$CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
}
else {
$CustomField = $NinjaValue | Ninja-Property-Set-Piped -Name $Name 2>&1
}
if ($CustomField.Exception) {
throw $CustomField
}
}
# Function to check if the computer is joined to a domain
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 to check if the computer is a domain controller
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
}
}
function Test-IsElevated {
$id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
$p = New-Object System.Security.Principal.WindowsPrincipal($id)
$p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}
function Test-IsDomainReachable {
try {
$searcher = [adsisearcher]"(&(objectCategory=computer)(name=$env:ComputerName))"
$searcher.FindOne()
}
catch {
Write-Host -Object "[Error] Failed to connect to the domain!"
Write-Host -Object "[Error] $($_.Exception.Message)"
$False
}
}
if (!$ExitCode) {
$ExitCode = 0
}
}
process {
# Check if the script is running with elevated privileges
if (!(Test-IsElevated)) {
Write-Host -Object "[Error] Access Denied. Please run with Administrator privileges."
exit 1
}
# Check if the computer is domain joined, can connect to the domain controller, and is not itself a domain controller
if ((Test-IsDomainJoined) -and !(Test-IsDomainReachable) -and !(Test-IsDomainController)) {
Write-Host -Object "[Error] Unable to connect to the domain controller! The domain must be reachable to confirm which profiles are orphaned."
exit 1
}
# Initialize a list to hold user profiles
$UserProfiles = New-Object System.Collections.Generic.List[Object]
# Retrieve user hives and add them to the list of user profiles
try {
$UserHives = Get-UserHives -Type "All"
}
catch {
Write-Host -Object "[Error] Failed to retrieve the user profile information from the registry!"
Write-Host -Object "$($_.Exception.Message)"
exit 1
}
$UserHives | ForEach-Object {
if ((Test-IsDomainJoined) -and $_.Username -notmatch [Regex]::Escape("$env:ComputerName") -and $_.Username -notmatch "AzureAD" -and $_.Username -ne "UNKNOWN") {
try {
$ADSIsearch = [adsisearcher]"(objectSid=$($_.SID))"
if (!($ADSIsearch.FindOne())) {
$_.Username = "UNKNOWN"
}
}
catch {
Write-Host -Object "[Error] Failed to connect to the domain to verify the account with the sid $($_.SID) is active."
Write-Host -Object "[Error] $($_.Exception.Message)"
exit 1
}
}
try {
$UserProfiles.Add(
[PSCustomObject]@{
SID = $_.SID
Username = $_.Username
UserHive = $_.UserHive
Path = $_.Path
Size = $_.Size
FriendlySize = (Get-FriendlySize -Bytes $_.Size)
}
)
}
catch {
Write-Host -Object "[Error] Failed to add the profile with the SID $($_.SID) to the profile list!"
Write-Host -Object "[Error] $($_.Exception.Message)"
exit 1
}
}
# Attempt to retrieve the user profiles directory from the registry (typically C:\Users)
try {
$ProfilesDirectory = (Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList' -ErrorAction Stop).ProfilesDirectory
}
catch {
Write-Host -Object "[Error] Unable to find the user profiles directory!"
Write-Host -Object "[Error] $($_.Exception.Message)"
exit 1
}
# Attempt to get information about directories in the profiles directory that have not already been identified/found
try {
$ProfilesDirectory | Get-ChildItem -Directory -Force -ErrorAction Stop | Where-Object { $DirectoriesToIgnore -notcontains $_.Name -and $UserProfiles.Path -notcontains $_.FullName } | ForEach-Object {
$FriendlySize = $Null
$Size = $Null
$Hive = $Null
# Check if the NTuser.dat file exists in the profile directory
if (Test-Path -Path "$($_.FullName)\NTuser.dat" -ErrorAction SilentlyContinue) {
$Hive = "$($_.FullName)\NTuser.dat"
}
else {
$Hive = "UNKNOWN"
}
# Calculate the size of the profile directory
$Size = $(Get-ChildItem -Path $_.FullName -Recurse -Force -ErrorAction SilentlyContinue | Measure-Object -Sum Length -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Sum -ErrorAction SilentlyContinue)
if ($Size) {
$FriendlySize = Get-FriendlySize -Bytes $Size
}
# Add the profile information to the list of user profiles
$UserProfiles.Add(
[PSCustomObject]@{
SID = "UNKNOWN"
Username = "UNKNOWN"
UserHive = $Hive
Path = $_.FullName
Size = $Size
FriendlySize = $FriendlySize
}
)
}
}
catch {
Write-Host -Object "[Error] Unable to get all of the user profile information for $($_.FullName)!"
Write-Host -Object "[Error] $($_.Exception.Message)"
exit 1
}
# Filter the list to find orphaned profiles (those with "UNKNOWN" as a username)
$OrphanedProfiles = $UserProfiles | Where-Object { $_.Username -eq "UNKNOWN" }
# If a custom field is specified, generate an HTML report and set the custom field
if ($CustomField) {
$HTMLreport = $UserProfiles | Sort-Object Size -Descending | Select-Object Username, @{Label = "Size"; Expression = { $_.FriendlySize } }, Path, SID | ConvertTo-Html -Fragment
# Highlight orphaned profiles in the HTML report
$HTMLreport = $HTMLreport | ForEach-Object {
$_ -replace '<tr><td>UNKNOWN</td>', '<tr class="danger"><td>UNKNOWN</td>'
}
try {
Write-Host "Attempting to set Custom Field '$CustomField'."
Set-NinjaProperty -Name $CustomField -Value $HTMLreport
Write-Host "Successfully set Custom Field '$CustomField'!"
}
catch {
Write-Host "[Error] $($_.Exception.Message)"
$ExitCode = 1
}
Write-Host ""
}
# Display a message about orphaned profiles
if ($OrphanedProfiles) {
Write-Host -Object "[Alert] Orphaned profiles found!"
$OrphanedProfiles | Sort-Object Size -Descending | Format-Table Username, @{Label = "Size"; Expression = { $_.FriendlySize } }, Path, SID | Out-String | Write-Host
}
else {
Write-Host -Object "No orphaned profiles found!"
}
exit $ExitCode
}
end {
}
Gagnez du temps avec plus de 300+ scripts du Dojo NinjaOne.
Description détaillée
Composants clés et flux de travail
1. Initialisation et paramètres
a. Le script commence par définir des paramètres tels que $DirectoriesToIgnore pour exclure des dossiers par défaut spécifiques (par exemple, “Public” ou “Default”) et $CustomField, qui s’intègre à NinjaOne à des fins de reporting.
b. Une série de fonctions d’aide telles que Test-IsDomainJoined et Get-FriendlySize préparent l’environnement en garantissant les privilèges appropriés et en formatant les résultats.
2. Découverte du profil
a. La fonctionnalité principale réside dans Get-UserHives, qui interroge le registre Windows pour obtenir des informations sur le profil de l’utilisateur. Il récupère des détails tels que le nom d’utilisateur, l’identifiant de sécurité (SID), le chemin d’accès au profil et la taille de chaque profil d’utilisateur.
b. Les profils sont comparés aux utilisateurs du domaine actif à l’aide de leur SID. Tout profil qui ne correspond pas à un utilisateur actif est marqué comme “INCONNU”
3. Génération de rapports
a. Le script compile tous les profils orphelins dans un rapport. Si un champ personnalisé est spécifié, il convertit les données en un rapport HTML pour l’intégration avec des outils externes comme NinjaOne.
4. Résultats et alertes
a. Si des profils orphelins sont trouvés, un tableau formaté s’affiche, indiquant les noms d’utilisateur, les tailles de profil, les chemins d’accès et les SID.
b. S’il n’existe aucun profil orphelin, le script l’indique.
Cas d’utilisation potentiels
Étude de cas : Nettoyer un réseau d’entreprise
Imaginez un MSP chargé de gérer une entreprise de 500 employés. Au fil des ans, plusieurs comptes sont désactivés lorsque les employés quittent l’entreprise, mais leurs profils sont conservés. Grâce à ce script, l’équipe informatique peut :
- Identifier les profils orphelins dans tous les systèmes.
- Analyser l’utilisation du disque attribuée à ces profils.
- Intégrer les résultats dans un système de reporting centralisé via le paramètre $CustomField.
- Utiliser les résultats pour prendre des décisions concernant l’archivage, la suppression ou la poursuite de l’enquête.
Comparaisons
Nettoyage manuel
L’examen manuel des profils utilisateur est un processus long et sujet aux erreurs, qui nécessite des recherches dans le registre et des références croisées avec les répertoires d’utilisateurs actifs. Ce script automatise le processus, ce qui garantit la cohérence et permet de gagner du temps.
Outils tiers
Certaines solutions logicielles sont spécialisées dans la gestion des profils utilisateur, mais leur coût est souvent élevé. Ce script PowerShell constitue une alternative économique et personnalisable, en particulier pour les entreprises qui utilisent déjà NinjaOne pour la gestion informatique.
FAQ
Comment le script identifie-t-il les comptes utilisateur orphelins ?
Il compare les informations relatives au profil de l’utilisateur extraites du registre Windows avec les comptes du domaine actif en résolvant les SID. Tout profil non associé à un compte actif est marqué comme orphelin.
Le script supprime-t-il les profils orphelins ?
Non, il ne fait qu’identifier et signaler les profils orphelins. Les administrateurs peuvent vérifier manuellement et prendre les décisions pertinentes.
Ce script peut-il être exécuté sur des systèmes autres que des domaines ?
Oui, mais sa capacité à valider les comptes par rapport à un domaine n’est pas disponible dans de tels environnements.
Quelles sont les autorisations requises pour exécuter le script ?
Des privilèges administrateur sont nécessaires pour accéder aux répertoires du registre et du profil.
Implications
L’identification des profils utilisateur orphelins a des implications considérables pour la sécurité et l’efficacité des technologies de l’information :
- Amélioration de la sécurité : réduction du risque d’exposition de données sensibles provenant de profils inutilisés.
- Ressources optimisées : libère l’espace disque et les ressources du système.
- Assurance de la conformité : aide les entreprises à répondre aux exigences en matière de gouvernance des données et d’audit.
Recommandations
- Test avant l’implémentation
Exécutez toujours le script dans un environnement de test afin de comprendre ses résultats et de vous assurer qu’il est conforme aux exigences de votre entreprise. - Examiner soigneusement les résultats
Les profils orphelins marqués comme “INCONNU” doivent être vérifiés pour s’assurer qu’ils ne sont pas associés à des comptes critiques. - Intégrer les rapports
Le paramètre $CustomField permet d’intégrer les résultats dans des outils tels que NinjaOne pour une gestion et une documentation centralisées. - Programmer des contrôles réguliers
Automatisez l’exécution régulière du script, afin que les systèmes restent propres et sécurisés.
Conclusion
Une gestion efficace des profils utilisateur est essentielle pour maintenir des environnements informatiques sécurisés et optimisés. Ce script PowerShell fournit une solution efficace et automatisée pour identifier les profils orphelins, offrant des informations détaillées et une intégration transparente avec des outils tels que NinjaOne. Pour les administrateurs informatiques et les MSP, l’implémentation de ces solutions garantit que les systèmes restent sécurisés, conformes et efficaces en termes de ressources.
En combinant ce script avec les capacités de gestion informatique plus larges de NinjaOne, les entreprises peuvent atteindre une efficacité inégalée dans la gestion des comptes et des profils utilisateur.