Comment surveiller les modifications de fichiers et garantir l’intégrité à l’aide de PowerShell

Dans le monde de l’informatique, le maintien de l’intégrité et de la sécurité des fichiers est primordial. Les professionnels de l’informatique et les fournisseurs de services gérés (MSP) ont besoin de méthodes fiables pour surveiller les modifications de fichiers afin d’empêcher les changements non autorisés, de garantir la conformité et de maintenir la stabilité du système. Cet article présente un puissant script PowerShell conçu pour vérifier l’existence d’un fichier, déterminer s’il a été modifié dans un laps de temps donné et vérifier son intégrité à l’aide d’un contrôle de hachage.

Contexte

Les professionnels de l’informatique et les MSP sont souvent confrontés au défi de s’assurer que les fichiers restent inchangés à moins d’être explicitement modifiés par le personnel autorisé. Les modifications non autorisées peuvent entraîner des failles de sécurité, des corruptions de données et des problèmes de conformité. Pour relever ces défis, une solution robuste est nécessaire pour surveiller les modifications des fichiers et garantir leur intégrité. Ce script PowerShell offre une approche rationalisée pour répondre à ces besoins, en fournissant des alertes basées sur des conditions spécifiques, telles que les modifications de fichiers ou l’absence de modifications.

Le script

<#
.SYNOPSIS
    Checks whether a file is present and if it has been updated within your specified time frame or fails a hash check.
.DESCRIPTION
    Checks whether a file is present and if it has been updated within your specified time frame or fails a hash check.

PARAMETER: -Alert "Alert If Change" or -Alert "Alert If No Change"
    Raise an alert if the file has or hasn't been modified based on your other parameters.

PARAMETER: -Hash "REPLACEMEC32D73431CED24FF114B2A216671C60117AF5012B40"
    The hash or checksum to verify that the file hasn't been modified.
PARAMETER: -Algorithm "SHA256"
    The hashing algorithm used for your inputted hash.
.EXAMPLE
    -Path "C:\TestFile.txt" -Hash "REPLACEME04C6F26CC32D73431CED24FF114B2A216671C60117AF5012B40" -Alert "Alert If No Change"

    C:\TestFile.txt exists!
    Hash Given: REPLACEME04C6F26CC32D73431CED24FF114B2A216671C60117AF5012B40
    Current Hash: 35BAFB1CE99AEF3AB068AFBAABAE8F21FD9B9F02D3A9442E364FA92C0B3EEEF0
    Hash mismatch!

.EXAMPLE
    -Path "C:\TestFile.txt" -Hash "35BAFB1CE99AEF3AB068AFBAABAE8F21FD9B9F02D3A9442E364FA92C0B3BEEF0" -Alert "Alert If No Change"

    C:\TestFile.txt exists!
    Hash Given: 35BAFB1CE99AEF3AB068AFBAABAE8F21FD9B9F02D3A9442E364FA92C0B3BEEF0
    Current Hash: 35BAFB1CE99AEF3AB068AFBAABAE8F21FD9B9F02D3A9442E364FA92C0B3BEEF0
    Hash matches!
    [Alert] File has not been modified!

PARAMETER: -Days "REPLACEMEWITHANUMBER"
    Raise an alert if the file hasn't been modified within the specified number of days. 
    Minutes and Hours are added to this time.

PARAMETER: -Hours "REPLACEMEWITHANUMBER"
    Raise an alert if the file hasn't been modified within the specified number of hours. 
    Days and Minutes are added to this time.

PARAMETER: -Minutes "REPLACEMEWITHANUMBER"
    Raise an alert if the file hasn't been modified within the specified number of minutes. 
    Days and Hours are added to this time.
.EXAMPLE
    -Path "C:\TestFile.txt" -Days 365 -Alert "Alert If Change"

    C:\TestFile.txt exists!
    Checking if the file was modified in the last 365 day(s) 00 hour(s) 00 minute(s)
    File was last modified on 02/07/2024 14:59:56.
    File has been updated within the time period.
    [Alert] File has been modified!
.EXAMPLE
    -Path "C:\TestFile.txt" -Days 30 -Alert "Alert If Change"

    C:\TestFile.txt exists!
    Checking if the file was modified in the last 30 day(s) 00 hour(s) 00 minute(s)
    File was last modified on 05/15/2023 15:13:55.
    File has not been modified within the time period.

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 8+, 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]$Alert,
    [Parameter()]
    [String]$Path,
    [Parameter()]
    [String]$Hash,
    [Parameter()]
    [String]$Algorithm = "SHA256",
    [Parameter()]
    [int]$Days,
    [Parameter()]
    [int]$Hours,
    [Parameter()]
    [int]$Minutes
)

begin {
    # Replace parameters with dynamic script variables
    if ($env:alert -and $env:alert -notlike "null") { $Alert = $env:alert }
    if ($env:targetFilePath -and $env:targetFilePath -notlike "null") { $Path = $env:targetFilePath }
    if ($env:hash -and $env:hash -notlike "null") { $Hash = $env:hash }
    if ($env:algorithm -and $env:algorithm -notlike "null") { $Algorithm = $env:algorithm }
    if ($env:daysSinceLastModification -and $env:daysSinceLastModification -notlike "null") { $Days = $env:daysSinceLastModification }
    if ($env:hoursSinceLastModification -and $env:hoursSinceLastModification -notlike "null") { $Hours = $env:hoursSinceLastModification }
    if ($env:minutesSinceLastModification -and $env:minutesSinceLastModification -notlike "null") { $Minutes = $env:minutesSinceLastModification }

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

    if (-not (Test-IsElevated)) {
        Write-Warning -Message "Some files or folders may require local Administrator permissions to view."
    }

    # Verify the given algorithm is supported by PowerShell
    $AllowedAlgorithms = "SHA1", "SHA256", "SHA384", "SHA512", "MD5"
    if ($AllowedAlgorithms -notcontains $Algorithm) {
        Write-Host "[Error] Invalid Algorithm selected ($Algorithm)! Allowed selections are 'SHA1','SHA256','SHA384','SHA512' and 'MD5'."
        exit 1
    }

    # Check for required parameter
    if (-Not ($Path)) {
        Write-Host "[Error] A filepath is required!"
        Exit 1
    }

    switch ($Alert) {
        "Alert If Change" { Write-Verbose "Alerting if file $Path has been modified." }
        "Alert If No Change" { Write-Verbose "Alerting if file $Path has not been modified." }
        default { Write-Verbose "No alert was selected." }
    }

    $ExitCode = 0
}
process {

    # File existence check
    if ($Path -and -Not (Test-Path $Path -ErrorAction SilentlyContinue)) {
        Write-Host "[Alert] $Path does not exist!"
        Exit 1
    }
    else {
        Write-Host "$Path exists!"
    }

    # Confirm we were given a filepath and not a directory
    $File = Get-Item -Path $Path -ErrorAction SilentlyContinue
    if ($File.PSIsContainer) {
        Write-Host "[Error] Please provide a file path, not a directory."
        Exit 1
    }

    # If given the files hash verify it matches
    if ($Hash) {
        $CurrentHash = Get-FileHash -Path $File.FullName -Algorithm $Algorithm | Select-Object -ExpandProperty Hash
        Write-Host "Hash Given: $Hash"
        Write-Host "Current Hash: $CurrentHash"

        if ($Hash -notlike $CurrentHash) {
            Write-Host "Hash mismatch!"

            if($Alert -eq "Alert If Change"){
                Write-Host "[Alert] File has been modified!"
                $ExitCode = 1
            }
        }
        else {
            Write-Host "Hash matches!"

            if($Alert -eq "Alert If No Change"){
                Write-Host "[Alert] File has not been modified!"
                $ExitCode = 1
            }
        }
    }

    # Get the current date and subtract the days, hours and minutes to compare with the file 
    $Cutoff = Get-Date
    $CurrentDate = $Cutoff

    if ($Days) { $Cutoff = $Cutoff.AddDays(-$Days) }
    if ($Hours) { $Cutoff = $Cutoff.AddHours(-$Hours) }
    if ($Minutes) { $Cutoff = $Cutoff.AddMinutes(-$Minutes) }

    $TimeSpan = New-TimeSpan $Cutoff $CurrentDate

    if (($Days -or $Hours -or $Minutes) -and ($Cutoff -ne $CurrentDate)) {
        Write-Host "Checking if the file was modified in the last $($TimeSpan.ToString("dd' day(s) 'hh' hour(s) 'mm' minute(s)'"))"
        Write-Host "File was last modified on $($File.LastWriteTime)."

        if ($File.LastWriteTime -ge $Cutoff) {
            Write-Host "File has been updated within the time period."

            if($Alert -eq "Alert If Change"){
                Write-Host "[Alert] File has been modified!"
                $ExitCode = 1
            }
        }
        else {
            Write-Host "File has not been updated within the time period."

            if($Alert -eq "Alert If No Change"){
                Write-Host "[Alert] File has not been modified!"
                $ExitCode = 1
            }
        }
    }

    Exit $ExitCode
}
end {

 

Description détaillée

Ce script PowerShell est conçu pour vérifier l’existence d’un fichier, vérifier s’il a été modifié dans un délai donné et effectuer une vérification du hachage pour assurer l’intégrité du fichier. Décortiquons le script étape par étape :

1. Définition de paramètres: Le script commence par définir des paramètres, notamment Alert, Path, Hash, Algorithm, Days, Hours et Minutes. Ces paramètres permettent aux utilisateurs de spécifier le fichier à surveiller, le hachage attendu, l’algorithme de hachage et le délai de vérification des modifications.
2. Remplacement de la variable d’environnement: Le script remplace dynamiquement les paramètres par des variables d’environnement si elles sont définies. Cette flexibilité permet une intégration aisée dans les systèmes automatisés et les scripts.
3. Vérification des autorisations de l’administrateur: Une fonction Test-IsElevated est utilisée pour vérifier si le script s’exécute avec des privilèges d’administrateur, afin de s’assurer qu’il dispose des autorisations nécessaires pour accéder aux fichiers spécifiés et les contrôler.
4. Validation de l’algorithme: Le script vérifie si l’algorithme de hachage fourni est pris en charge. Les algorithmes autorisés sont SHA1, SHA256, SHA384, SHA512 et MD5.
5. Vérification de l’existence et du type de fichier: Le script vérifie si le chemin spécifié existe et confirme qu’il s’agit d’un fichier et non d’un répertoire.
6. Vérification du hachage: Si un hachage est fourni, le script calcule le hachage actuel du fichier à l’aide de l’algorithme spécifié et le compare au hachage donné. Il émet ensuite une alerte en cas de non-concordance ou si le fichier n’a pas été modifié en fonction du paramètre Alert.
7. Contrôle de l’heure de modification: Le script calcule l’heure limite en fonction des paramètres jours, heures et minutes fournis. Il compare ensuite l’heure de la dernière modification du fichier à l’heure limite et émet une alerte si le fichier a été modifié ou non dans le délai spécifié.

Cas d’utilisation potentiels

Imaginez un professionnel de l’informatique chargé de maintenir la sécurité et l’intégrité des fichiers de configuration sensibles sur un serveur. À l’aide de ce script, ils peuvent mettre en place un contrôle quotidien pour vérifier si des fichiers critiques ont été modifiés. Par exemple, ils peuvent utiliser le script pour surveiller un fichier de configuration et s’assurer qu’il n’a pas été modifié de manière inattendue. Si le script détecte un changement, il émet une alerte, ce qui permet à l’informaticien d’enquêter et de prendre les mesures qui s’imposent.

Comparaisons

Ce script PowerShell présente plusieurs avantages par rapport à d’autres méthodes de surveillance des modifications de fichiers, telles que l’utilisation de logiciels tiers ou les vérifications manuelles :

• Rapport coût-efficacité: Comme il s’agit d’un script PowerShell, il n’est pas nécessaire d’avoir recours à des solutions tierces coûteuses.

• Personnalisation: Les utilisateurs peuvent facilement modifier le script pour l’adapter à leurs besoins spécifiques.

• Intégration: Le script peut être intégré dans les flux de travail et les systèmes d’automatisation existants.

FAQ

1) Comment exécuter ce script ?

Pour exécuter le script, enregistrez-le en tant que fichier .ps1 et exécutez-le dans PowerShell avec les paramètres appropriés.

2) Ce script peut-il surveiller plusieurs fichiers à la fois ?

Le script est conçu pour surveiller un fichier à la fois. Cependant, vous pouvez le modifier pour qu’il passe en boucle dans plusieurs fichiers si nécessaire.

3) Que se passe-t-il si je n’ai pas les droits d’administrateur ?

Le script émet un avertissement et certains fichiers ou dossiers peuvent ne pas être accessibles sans les autorisations nécessaires.

Implications

L’utilisation de ce script pour surveiller les modifications de fichiers a des implications importantes pour la sécurité informatique. Il garantit que toute modification non autorisée est rapidement détectée, ce qui permet de réagir rapidement et de prendre des mesures d’atténuation. Un contrôle régulier permet de maintenir l’intégrité du système, de garantir le respect des politiques de sécurité et de se prémunir contre d’éventuelles violations.

Recommandations

• Contrôles réguliers: Planifiez des contrôles réguliers pour assurer une surveillance continue des fichiers critiques.

• Intégration: Intégrez le script à vos outils de gestion et d’automatisation informatiques existants pour un fonctionnement sans faille.

• Sauvegarde: Conservez toujours des sauvegardes des fichiers critiques afin de les restaurer en cas de modifications non autorisées.

Conclusion

La surveillance des modifications de fichiers est cruciale pour le maintien de la sécurité et de l’intégrité des technologies de l’information. Ce script PowerShell fournit une solution efficace et personnalisable pour les professionnels de l’informatique et les MSP. En intégrant ce script dans votre flux de travail, vous pouvez assurer une surveillance continue et une détection rapide de toute modification non autorisée. Pour des solutions de gestion informatique plus complètes, envisagez d’explorer NinjaOne, une plateforme puissante conçue pour améliorer vos opérations et votre sécurité informatiques.