Comment maîtriser la sécurité des démarrages : guide de script PowerShell pour l’audit Autorunsc

Points à retenir

• Audit complet: Le script fournit un audit complet des éléments de démarrage, améliorant ainsi la sécurité et les performances du système.
• Automatisation et efficacité: Automatise le processus de téléchargement et d’exécution d’Autorunsc, ce qui permet de gagner du temps par rapport aux méthodes manuelles.
• Paramètres personnalisables: Permet de cibler des entrées d’exécution automatique spécifiques telles que des services, des tâches planifiées ou des applications de démarrage.
• Facilité d’établissement des rapports: Les résultats sont enregistrés dans un journal d’activité et, en option, dans des champs personnalisés pour faciliter la documentation et l’examen.
• Nécessité d’avoir des droits d’administrateur: Des privilèges d’administrateur sont nécessaires pour bénéficier de toutes les fonctionnalités, en particulier pour écrire dans les champs personnalisés.
• Compatibilité : Conçu pour Windows 10 et Server 2012, il garantit une large applicabilité dans les environnements informatiques modernes.
• Identification des logiciels malveillants: Aide à identifier les entrées d’exécution automatique suspectes, ce qui constitue une étape cruciale dans la détection et la prévention des logiciels malveillants.
• Audits réguliers: Il est conseillé d’utiliser régulièrement le script pour maintenir l’intégrité et la sécurité du système.
• Analyse minutieuse des résultats: Nécessité d’examiner attentivement les résultats des audits afin d’éviter les faux positifs et de garantir la fiabilité du système.
• Intégration avec les outils de gestion informatique: Met en évidence la façon dont l’intégration avec des outils tels que NinjaOne peut améliorer la gestion informatique et les stratégies de sécurité.

Comprendre les subtilités des systèmes informatiques, en particulier dans le domaine de la sécurité et de la gestion des démarrages, est essentiel pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). L’audit et la gestion efficaces des entrées d’exécution automatique sont essentiels au maintien de l’intégrité et de la sécurité du système. Cet article traite d’un script PowerShell qui exploite Autorunsc, un outil de Sysinternals, pour réaliser des audits de démarrage complets.

Contexte

Le script en question est conçu pour exécuter Autorunsc avec divers paramètres définis par l’utilisateur, en affichant les résultats dans un journal d’activité et éventuellement dans un champ personnalisé. Autorunsc est un outil renommé de Sysinternals, développé par Mark Russinovich. Il fournit un aperçu détaillé de tous les programmes et scripts configurés pour être exécutés lors du démarrage du système ou de la connexion de l’utilisateur.

Pour les professionnels de l’informatique et les entreprises MSP, ce script est un atout puissant, qui leur permet d’identifier rapidement les éléments de démarrage potentiellement malveillants ou inutiles, afin d’améliorer les performances et la sécurité du système.

Le script :

#Requires -Version 4

<#
.SYNOPSIS
    Runs Autorunsc with your selected options and outputs the results to the activity log and optionally a WYSIWYG custom field. Please note that there is a limit to the number of results that can be set in Custom Fields or viewed in the Activity Log.
.DESCRIPTION
    Runs Autorunsc with your selected options and outputs the results to the activity log and optionally a WYSIWYG custom field. Please note that there is a limit to the number of results that can be set in Custom Fields or viewed in the Activity Log.
.EXAMPLE
    (No Parameters)
    URL Given, Downloading the file...
    Download Attempt 1
    HKCU:\SOFTWARE\Sysinternals\AutoRuns\EulaAccepted changed from 1 to 1

    Sysinternals Autoruns v14.10 - Autostart program viewer
    Copyright (C) 2002-2023 Mark Russinovich
    Sysinternals - www.sysinternals.com

    WARNING: Script must be elevated in order to write to custom field.
    
    Entry          : C:\Windows\system32\userinit.exe
    Entry Location : HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Userinit
    Image Path     : c:\windows\system32\userinit.exe
    Signer         : (Verified) Microsoft Windows
    MD5            : 9C4C281156040CF01EA35D759092F540

    Entry          : cmd.exe
    Entry Location : HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\AlternateShell
    Image Path     : c:\windows\system32\cmd.exe
    Signer         : (Verified) Microsoft Windows
    MD5            : 8A2122E8162DBEF04694B9C3E0B6CDEE

PARAMETER: -CustomField "ReplaceWithAMultilineCustomField"
    The name of the multiline custom field you would like to save the results to.

PARAMETER: -Startup
    Applications or scripts configured to run automatically after a user logs into their account. This is the default option for Autoruns. 
    E.g. Applications in the 'Startup' folder.

PARAMETER: -Boot
    Programs or commands that are set to execute during the system's boot-up sequence before a user logs in.

PARAMETER: -WinLogon
    Items that are configured to run during the Windows logon process. Often these items are critical to the logon UI.

PARAMETER: -AppInit
    DLLs that are automatically loaded by every process that calls the User32.dll file (anything with a GUI).

PARAMETER: -Explorer
    Plugins or extensions that integrate into the Windows Explorer shell.

PARAMETER: -Sidebar
    Mini applications or gadgets that load into the desktop sidebar in earlier versions of Windows (introduced in Windows Vista).

PARAMETER: -ImageHijacks
    Registry modifications that redirect the execution of specific executable files to a different program.

PARAMETER: -IEAddons
    Browser extensions or toolbars that Internet Explorer will load automatically when it starts.

PARAMETER: -KnownDLLs
    Crucial system DLLs that Windows will load into memory at startup.

PARAMETER: -WMIentries
    Entries related to WMI scripts or providers that are set to execute automatically.

PARAMETER: -WinSockProtocols
    Modules or services meant to load up with the Windows network stack.

PARAMETER: -Codecs
    Software components meant to be used for encoding or decoding digital media streams (often set to run at system startup).

PARAMETER: -PrinterMonitor
    DLL's associated with printer drivers.

PARAMETER: -LSAProviders
    Plugins that integrate with the Local Security Authority subsystem.

PARAMETER: -Services
    Windows Services set to start Automatically.

PARAMETER: -ScheduledTasks
    These are tasks set in Task Scheduler to do something automatically at a specified interval.

PARAMETER: -HideMicrosoftEntries
    Hides Signed Microsoft Entries from the results.

PARAMETER: -DestinationFolder
    By default this script downloads autorunsc to the temp folder.

PARAMETER: -DownloadUrl
    URL to download Autoruns from.

PARAMETER: -SkipSleep
    Skips sleeping prior to downloading autorunsc.
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Server 2012
    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).
#>

[CmdletBinding()]
param (
    [Parameter()]
    [String]$CustomField,
    [Parameter()]
    [Switch]$Startup = [System.Convert]::ToBoolean($env:checkLogonStartupEntries),
    [Parameter()]
    [Switch]$Boot = [System.Convert]::ToBoolean($env:checkBootEntries),
    [Parameter()]
    [Switch]$WinLogon = [System.Convert]::ToBoolean($env:checkWinlogonEntries),
    [Parameter()]
    [Switch]$AppInit = [System.Convert]::ToBoolean($env:checkAppinitEntries),
    [Parameter()]
    [Switch]$Explorer = [System.Convert]::ToBoolean($env:checkExplorerAddons),
    [Parameter()]
    [Switch]$Sidebar = [System.Convert]::ToBoolean($env:checkSidebarGadgets),
    [Parameter()]
    [Switch]$ImageHijacks = [System.Convert]::ToBoolean($env:checkImageHijacks),
    [Parameter()]
    [Switch]$IEAddons = [System.Convert]::ToBoolean($env:checkInternetExplorerAddons),
    [Parameter()]
    [Switch]$KnownDLLs = [System.Convert]::ToBoolean($env:checkKnownDlls),
    [Parameter()]
    [Switch]$WMIentries = [System.Convert]::ToBoolean($env:checkWmiEntries),
    [Parameter()]
    [Switch]$WinSockProtocols = [System.Convert]::ToBoolean($env:checkWinsockProtocol),
    [Parameter()]
    [Switch]$Codecs = [System.Convert]::ToBoolean($env:checkCodecs),
    [Parameter()]
    [Switch]$PrinterMonitor = [System.Convert]::ToBoolean($env:checkPrinterMonitorDlls),
    [Parameter()]
    [Switch]$LSAProviders = [System.Convert]::ToBoolean($env:checkLsaSecurityProviders),
    [Parameter()]
    [Switch]$Services = [System.Convert]::ToBoolean($env:checkAutostartServices),
    [Parameter()]
    [Switch]$ScheduledTasks = [System.Convert]::ToBoolean($env:checkScheduledTasks),
    [Parameter()]
    [Switch]$HideMicrosoftEntries = [System.Convert]::ToBoolean($env:hideMicrosoftEntries),
    [Parameter()]
    [String]$DestinationFolder = "$env:Temp",
    [Parameter()]
    [String]$DownloadUrl = "https://download.sysinternals.com/files/Autoruns.zip",
    [Parameter()]
    [Switch]$SkipSleep = [System.Convert]::ToBoolean($env:skipSleep)
)

begin {

    # If Script Forms are used replace the parameters
    if ($env:destinationFolder -and $env:DestinationFolder -notlike "null") { $DestinationFolder = $env:destinationFolder }
    if ($env:downloadUrl -and $env:downloadUrl -notlike "null") { $DownloadUrl = $env:downloadUrl }
    if ($env:customFieldName -and $env:customFieldName -notlike "null") { $CustomField = $env:customFieldName }

    if ($PSVersionTable.PSVersion.Major -lt 5) {
        function Expand-Archive {
            [CmdletBinding()]
            param(
                [Parameter()]
                [String]$Path,
                [Parameter()]
                [String]$DestinationPath,
                [Parameter()]
                [Switch]$Force
            )
            begin {
                Add-Type -assembly "System.IO.Compression.FileSystem"
            }
            process {
                if ($Force -and (Test-Path $DestinationPath)) {
                    $ZipFile = [System.IO.Compression.ZipFile]::OpenRead($Path)

                    $ZipFile.Entries | ForEach-Object {
                        $Destination = [System.IO.Path]::Combine($DestinationPath, $_.FullName)
                        $DestinationDir = [System.IO.Path]::GetDirectoryName($Destination)
                        if (-not (Test-Path $DestinationDir)) {
                            New-Item -ItemType Directory -Path $DestinationDir -Force
                        }
                        [System.IO.Compression.ZipFileExtensions]::ExtractToFile($_, $Destination, $True)
                    }
                    $ZipFile.Dispose()
                }
                else {
                    [System.IO.Compression.ZipFile]::ExtractToDirectory($Path, $DestinationPath)
                }
            }
        }
    }

    # Handy download function
    function Invoke-Download {
        param(
            [Parameter()]
            [String]$URL,
            [Parameter()]
            [String]$Path,
            [Parameter()]
            [Switch]$SkipSleep
        )

        Write-Host "URL Given, Downloading the file..."

        $SupportedTLSversions = [enum]::GetValues('Net.SecurityProtocolType')
        if ( ($SupportedTLSversions -contains 'Tls13') -and ($SupportedTLSversions -contains 'Tls12') ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol::Tls13 -bor [System.Net.SecurityProtocolType]::Tls12
        }
        elseif ( $SupportedTLSversions -contains 'Tls12' ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
        }
        else {
            # Not everything requires TLS 1.2, but we'll try anyways.
            Write-Warning "TLS 1.2 and or TLS 1.3 isn't supported on this system. This download may fail!"
            if ($PSVersionTable.PSVersion.Major -lt 3) {
                Write-Warning "PowerShell 2 / .NET 2.0 doesn't support TLS 1.2."
            }
        }

        $i = 1
        While ($i -lt 4) {
            if (-not ($SkipSleep)) {
                $SleepTime = Get-Random -Minimum 3 -Maximum 60
                Start-Sleep -Seconds $SleepTime
            }

            Write-Host "Download Attempt $i"

            try {
                $WebClient = New-Object System.Net.WebClient
                $WebClient.DownloadFile($URL, $Path)
            }
            catch {
                Write-Warning "An error has occurred while downloading!"
            }

            $File = Test-Path -Path $Path -ErrorAction SilentlyContinue
            if ($File) {
                $i = 4
            }
            else {
                $i++
            }
        }

        if (-not $File) { 
            Write-Error -Message "File failed to download!" -Category DeviceError -Exception (New-Object System.Exception)
            Exit 1 
        }
    }

    # Need to set Regkey to accept EULA
    function Set-RegKey {
        param (
            $Path,
            $Name,
            $Value,
            [ValidateSet("DWord", "QWord", "String", "ExpandedString", "Binary", "MultiString", "Unknown")]
            $PropertyType = "DWord"
        )
        if (-not $(Test-Path -Path $Path)) {
            # Check if path does not exist and create the path
            New-Item -Path $Path -Force | Out-Null
        }
        if ((Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue)) {
            # Update property and print out what it was changed from and changed to
            $CurrentValue = (Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name
            try {
                Set-ItemProperty -Path $Path -Name $Name -Value $Value -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error -Message "[Error] Unable to Set registry key for $Name please see below error!" -Category DeviceError -Exception (New-Object System.Exception)
                Write-Error $_
                exit 1
            }
            Write-Host "$Path\$Name changed from $CurrentValue to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
        else {
            # Create property with value
            try {
                New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $PropertyType -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Error -Message "[Error] Unable to Set registry key for $Name please see below error!" -Category DeviceError -Exception (New-Object System.Exception)
                Write-Error $_
                exit 1
            }
            Write-Host "Set $Path\$Name to $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction SilentlyContinue).$Name)"
        }
    }

    function Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )

        $Characters = $Value | Measure-Object -Character | Select-Object -ExpandProperty Characters
        if($Characters -ge 10000){
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded, value is greater than 10,000 characters.")
        }
    
        # If we're requested to set the field value for a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
    
        # This is a list of valid fields that can be set. If no type is given, it will be assumed that the input doesn't 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 be set
        $NeedsOptions = "Dropdown"
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                # 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.
                $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 it will have an exception property, the function will exit with that error information.
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
    
        # The below type's require values not typically given in order to be set. The below code will convert whatever we're given into a format ninjarmm-cli supports.
        switch ($Type) {
            "Checkbox" {
                # While it's highly likely we were given a value like "True" or a boolean datatype 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, the given value will be matched 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 is expecting the guid of the option we're trying to select. So we'll match up 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")
                }
    
                $NinjaValue = $Selection
            }
            default {
                # All the other types shouldn't require additional work on the input.
                $NinjaValue = $Value
            }
        }
    
        # We'll need to set the field differently depending on if its a field in a Ninja Document or not.
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            $CustomField = Ninja-Property-Set -Name $Name -Value $NinjaValue 2>&1
        }
    
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }

    # Test for elevation
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    $ExitCode = 0
}
process {

    # Take the script parameters and translate them into Autoruns options.
    if ($Startup) { $AutorunOptions = "l" }
    if ($Boot) { $AutorunOptions = "$($AutorunOptions)b" }
    if ($Winlogon) { $AutorunOptions = "$($AutorunOptions)w" }
    if ($AppInit) { $AutorunOptions = "$($AutorunOptions)d" }
    if ($Explorer) { $AutorunOptions = "$($AutorunOptions)e" }
    if ($Sidebar) { $AutorunOptions = "$($AutorunOptions)g" }
    if ($ImageHijacks) { $AutorunOptions = "$($AutorunOptions)h" }
    if ($IEAddons) { $AutorunOptions = "$($AutorunOptions)i" }
    if ($KnownDLLs) { $AutorunOptions = "$($AutorunOptions)k" }
    if ($WMIentries) { $AutorunOptions = "$($AutorunOptions)m" }
    if ($WinSockProtocols) { $AutorunOptions = "$($AutorunOptions)n" }
    if ($Codecs) { $AutorunOptions = "$($AutorunOptions)o" }
    if ($PrinterMonitor) { $AutorunOptions = "$($AutorunOptions)p" }
    if ($LSAProviders) { $AutorunOptions = "$($AutorunOptions)r" }
    if ($Services) { $AutorunOptions = "$($AutorunOptions)s" }
    if ($ScheduledTasks) { $AutorunOptions = "$($AutorunOptions)t" }

    if (-not $AutorunOptions){
        Write-Error -Message "No Autoruns options selected. Please at least select one option to search for autostart entries." -Category InvalidArgument -Exception (New-Object System.ArgumentNullException)
        exit 1
    }

    # Download the file and unzip its contents
    $DownloadArguments = @{
        URL  = $DownloadUrl
        Path = "$DestinationFolder\Autoruns.zip"
    }
    if ($SkipSleep) { $DownloadArguments["SkipSleep"] = $true }

    # Download and unzip
    Invoke-Download @DownloadArguments
    Expand-Archive -Path "$DestinationFolder\Autoruns.zip" -DestinationPath "$DestinationFolder\Autoruns" -Force

    if (-not (Test-Path "$DestinationFolder\Autoruns\autorunsc64.exe" -ErrorAction SilentlyContinue)) {
        Write-Error -Message "Failed to unzip Autoruns" -Category DeviceError -Exception (New-Object System.Exception)
        exit 1
    }

    # Now that we have the options create an argument list using those options
    $ArgumentList = New-Object System.Collections.Generic.List[string]
    $ArgumentList.Add("-a $AutorunOptions")
    $ArgumentList.Add("-h")
    $ArgumentList.Add("-c")
    $ArgumentList.Add("-s")
    if ($HideMicrosoftEntries) { $ArgumentList.Add("-m") }

    # Accept EULA
    Set-RegKey -Path "HKCU:\SOFTWARE\Sysinternals\AutoRuns" -Name "EulaAccepted" -Value 1

    # Run autoruns and store the results as a csv and then import the results into powershell
    Start-Process "$DestinationFolder\Autoruns\autorunsc64.exe" -ArgumentList $ArgumentList -NoNewWindow -RedirectStandardOutput "$DestinationFolder\Autoruns\autorunsc.csv" -Wait
    $AutorunResults = Import-Csv "$DestinationFolder\Autoruns\autorunsc.csv" | Where-Object { $_.Entry } | Sort-Object Entry | Select-Object Entry, "Entry Location", "Image Path", Signer, MD5

    if (-not ($AutorunResults)) {
        Write-Error -Message "No startup entries found. Is Autorunsc being blocked?" -Category InvalidResult -Exception (New-Object System.ApplicationException)
        $ExitCode = 1
    }

    # Set the custom field with the Autoruns results.
    if ($CustomField) {
        if ($PSVersionTable.PSVersion.Major -lt 3) {
            Write-Warning "Ninjarmm-cli does not support setting custom fields using PowerShell 2.0"
            $ExitCode = 1
        }
        
        if ( -not (Test-IsElevated)) {
            Write-Warning "Script must be elevated in order to write to custom field."
            $ExitCode = 1
        }

        try {
            Write-Host "Attempting to set Custom Field '$CustomField'."
            $htmlTable = $AutorunResults | ConvertTo-HTML -Fragment
            Set-NinjaProperty -Name $CustomField -Value $htmlTable
            Write-Host "Successfully set Custom Field '$CustomField'!"
        }
        catch {
            $_
            $ExitCode = 1
        }
    }

    # Clean up our leftover files.
    Remove-Item "$DestinationFolder\Autoruns" -Recurse -Force
    Remove-Item "$DestinationFolder\Autoruns.zip" -Force

    # Output results into activity log. Using Format-List due to size of table.
    $AutorunResults | Sort-Object Entry | Format-List

    exit $ExitCode
}
end {
    
    
    
}

 

Description détaillée

Le script commence par définir des paramètres qui permettent aux utilisateurs de spécifier différents types d’entrées d’exécution automatique à auditer, tels que les applications de démarrage, les exécutables d’amorçage et les tâches planifiées. Il télécharge l’outil Autorunsc, l’exécute avec les paramètres choisis et collecte les résultats.

Les étapes clés du script :

• Initialisation des paramètres : Les utilisateurs peuvent sélectionner le type d’entrées d’exécution automatique qu’ils souhaitent auditer, comme les éléments de démarrage, les tâches planifiées ou les services.
• Téléchargement d’Autorunsc : Le script télécharge automatiquement Autorunsc de Sysinternals.
• Exécution et traitement des résultats : Autorunsc est exécuté avec les paramètres spécifiés et les résultats sont formatés dans un format lisible.
• Écriture dans un champ personnalisé: optionnellement, les résultats peuvent être écrits dans un champ personnalisé, à condition que le script soit exécuté avec des privilèges élevés.
• Nettoyage : après l’exécution, le script efface les fichiers téléchargés et générés temporairement.

Cas d’utilisation potentiels

Imaginez un professionnel de l’informatique qui soupçonne l’existence d’un logiciel non autorisé ou nuisible s’exécutant au démarrage dans les systèmes de son entreprise. En exécutant ce script, il peut rapidement vérifier tous les éléments de démarrage et identifier toute application indésirable ou suspecte, améliorant ainsi la sécurité et les performances du système.

Comparaisons

Les méthodes traditionnelles d’audit des éléments de démarrage impliquent souvent de vérifier manuellement divers emplacements du système ou d’utiliser des outils distincts pour les différents types de démarrage. Ce script simplifie et consolide le processus, en utilisant un seul outil (Autorunsc) pour vérifier une gamme complète d’entrées d’exécution automatique. Par rapport aux méthodes manuelles, ce script permet de gagner du temps et réduit la probabilité d’oublier des éléments essentiels.

FAQ

Q1 : Ce script est-il adapté à toutes les versions de Windows ?
A1 : Le script est conçu pour Windows 10 et Server 2012.

Q2 : Ai-je besoin de droits d’administrateur pour exécuter ce script ?
A2 : Oui, des privilèges d’administrateur sont nécessaires pour certaines opérations, comme l’écriture dans un champ personnalisé.

Q3 : Ce script peut-il identifier les logiciels malveillants ?
A3 : Bien qu’il puisse identifier des éléments de démarrage non autorisés ou inconnus, une analyse plus approfondie est nécessaire pour déterminer s’il s’agit de logiciels malveillants.

Implications

L’utilisation de ce script pour l’audit des éléments de démarrage est importante pour la sécurité informatique. L’identification et la gestion de l’exécution automatique peuvent empêcher les logiciels malveillants de s’exécuter au démarrage et améliorer les performances du système. Toutefois, il est essentiel d’analyser soigneusement les résultats de l’audit afin d’éviter les faux positifs et de s’assurer que des logiciels légitimes ne sont pas bloqués par inadvertance.

Recommandations

Les bonnes pratiques lors de l’utilisation de ce script sont les suivantes :

• Audits réguliers pour maintenir l’intégrité du système.
• Exécuter le script avec des privilèges d’administrateur pour une fonctionnalité complète.
• Analyse minutieuse des résultats de l’audit afin d’identifier les entrées d’exécution automatique non autorisées ou inutiles et de prendre les mesures qui s’imposent.

Conclusion

Dans le cadre d’une gestion efficace des systèmes informatiques, des outils comme NinjaOne, associés à des scripts puissants tels que le script d’audit d’autorunsc PowerShell, peuvent considérablement améliorer la capacité d’un professionnel de l’informatique à maintenir l’intégrité et la sécurité de son système. La suite complète de gestion informatique de NinjaOne, intégrée à ces scripts, offre une solution de pointe pour la surveillance, la gestion et la sécurisation des infrastructures informatiques.