Comment utiliser PowerShell pour surveiller les fichiers texte et déclencher des alertes pour les professionnels de l’informatique

Dans le monde informatique actuel, l’automatisation est la clé d’une gestion et d’une surveillance efficaces des systèmes. PowerShell, avec ses puissantes capacités de script, est un outil de choix pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui cherchent à optimiser leurs flux de travail. L’une des tâches les plus courantes consiste à surveiller les fichiers texte à la recherche d’un contenu spécifique, que ce soit pour suivre les journaux, détecter les erreurs ou alerter sur des informations critiques.

Le script PowerShell que nous présentons aujourd’hui vous alerte lorsqu’un texte spécifié est trouvé dans un fichier texte, ce qui en fait un outil précieux pour les personnes chargées de maintenir l’intégrité et la sécurité des systèmes informatiques.

Contexte

Les fichiers texte sont souvent utilisés dans les environnements informatiques pour enregistrer des activités, stocker des données de configuration ou conserver des informations cruciales. La surveillance de ces fichiers à l’aide de mots-clés ou de phrases spécifiques est cruciale pour diverses raisons, telles que la détection des failles de sécurité, la garantie de la conformité ou l’identification des défaillances du système.

Traditionnellement, les professionnels de l’informatique peuvent inspecter manuellement ces fichiers ou utiliser des solutions logicielles complexes pour les contrôler. Cependant, grâce à PowerShell, vous pouvez automatiser ce processus à l’aide d’un script simple mais efficace. Ce script est particulièrement utile pour les MSP qui gèrent plusieurs clients et qui ont besoin d’un moyen fiable de surveiller les fichiers texte dans différents environnements.

Le script :

#Requires -Version 4

<#
.SYNOPSIS
    Alert when the specified text is found in a text file.
.DESCRIPTION
    Alert when the specified text is found in a text file.
.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##

PARAMETER: -Path "C:\ReplaceMe\WithPath\To\Text.txt"
    File path to the text file you would like to monitor.

PARAMETER: -TextToMatch "ReplaceMeWithTextToFind"
   Text to alert on when found.

.EXAMPLE
    -Path "C:\Test-FileMonitor.txt" -TextToMatch "bat"
    
    [Alert] Found Text!

.EXAMPLE
    -Path "C:\Test-FileMonitor.txt" -TextToMatch "man" -MatchOnlyOnWholeWord
    
    Text Not Found!

PARAMETER: -MatchOnlyOnWholeWord
    Alert only when your given 'Text To Match' is not contained in another word.

PARAMETER: -CaseSensitive
    Alert only when the casing of your specified 'Text To Match' is identical; for example, alert on 'BAT' but not 'bat'.
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows 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://ninjastage2.wpengine.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]$Path,
    [Parameter()]
    [String]$TextToMatch,
    [Parameter()]
    [Switch]$WholeWordOnly = [System.Convert]::ToBoolean($env:matchOnlyOnWholeWord),
    [Parameter()]
    [Switch]$CaseSensitive = [System.Convert]::ToBoolean($env:caseSensitive)
)

begin {
    # Set Dynamic Script Variables
    if($env:textToMatch -and $env:textToMatch -notlike "null"){
        $TextToMatch = $env:textToMatch
    }
    if($env:textFilePath -and $env:textFilePath -notlike "null"){
        $Path = $env:textFilePath
    }

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

    # Check that a path was given and if not error out.
    if (-not $Path) {
        Write-Host "[Error] A filepath is required!"
        exit 1
    }

    # If not given text to match error out.
    if (-not $TextToMatch){
        Write-Host "[Error] Text to match is required!"
        exit 1
    }

    # Error out if script is running without local administrator rights.
    if (-not (Test-IsElevated)) {
        Write-Host "[Error] Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Check that the path given exists.
    if (-not (Test-Path -Path $Path)) {
        Write-Host "[Error] File does not exist!"
        exit 1
    }

    # Check that we're given a file and not a folder.
    $File = Get-Item -Path $Path
    if ($File.PSIsContainer) {
        Write-Host "[Error] Please provide a file path, not a directory."
        exit 1
    }

    $ExitCode = 0
}
process {
    # Check if we were given a binary file and if so error out.
    $ByteCount = 1024
    $ByteArray = Get-Content -Path $Path -Encoding Byte -TotalCount $ByteCount
    if ($ByteArray -contains 0 ) {
        Write-Host "[Error] This script does not support searching binary files!"
        exit 1
    }

    # Retrieve file contents.
    $File = Get-Content -Path $Path

    # If file is empty error out.
    if (-not $File) {
        Write-Host "[Error] reading file, file is either empty or you do not have permission to read it."
        exit 1
    }

    # Scan through each-line checking for our text.
    $File | ForEach-Object {
        # Based on the parameters given match the text.  
        if (-not $CaseSensitive -and -not $WholeWordOnly -and $_ -like "*$TextToMatch*") {
            $Match = $True
        }

        if ($CaseSensitive -and -not $WholeWordOnly -and $_ -clike "*$TextToMatch*") {
            $Match = $True
        }

        if ($WholeWordOnly -and -not $CaseSensitive -and $_ -match "\b$TextToMatch\b") {
            $Match = $True
        }

        if ($WholeWordOnly -and $CaseSensitive -and $_ -cmatch "\b$TextToMatch\b") {
            $Match = $True
        }
    }

    # If our text matched alert.
    if ($Match) {
        Write-Host "[Alert] Found Text!"
    }
    else {
        Write-Host "Text Not Found!"
    }

    exit $ExitCode
}
end {
    
    
    
}

 

Description détaillée

Le script fourni est conçu pour surveiller un fichier texte à la recherche d’un contenu spécifique et alerter l’utilisateur lorsque le texte est trouvé. Voici une description étape par étape du fonctionnement du script :

1. Paramétrage :

• Le script commence par définir des paramètres tels que -Path (le chemin d’accès au fichier texte que vous souhaitez surveiller) et -TextToMatch (le texte que vous souhaitez trouver). Les paramètres facultatifs comprennent -WholeWordOnly pour s’assurer que le texte n’est pris en compte que lorsqu’il apparaît sous la forme d’un mot entier, et -CaseSensitive pour différencier les majuscules et les minuscules.

2. Variables d’environnement:

• Le script vérifie si des variables d’environnement sont définies pour textToMatch et textFilePath. Si c’est le cas, ces valeurs remplacent les paramètres fournis par l’utilisateur.

3. Validation des privilèges et des chemins d’accès :

• Le script comprend une fonction permettant de vérifier s’il s’exécute avec des privilèges d’administrateur, ce qui est nécessaire pour accéder à certains fichiers ou chemins d’accès au système. Il vérifie également que le chemin d’accès fourni existe et qu’il pointe sur un fichier valide plutôt que sur un répertoire.

4. Recherche de contenu de fichier:

• Le script lit le contenu du fichier spécifié. Si le fichier est vide ou si l’utilisateur n’a pas le droit de le lire, le script est interrompu, ce qui empêche toute exécution ultérieure.

5. Logique de correspondance des textes:

• Le script parcourt chaque ligne du fichier en appliquant les critères de correspondance de texte spécifiés. Il vérifie si les options -CaseSensitive ou -WholeWordOnly sont activées et ajuste la logique de correspondance en conséquence. Si le texte est trouvé, le script avertit l’utilisateur en affichant “[Alert] Found Text!” ; sinon, il affiche “Text Not Found!”.

6. Gestion des erreurs:

• Tout au long de son exécution, le script inclut une gestion performante des erreurs afin de garantir qu’il se termine de manière utile avec des messages d’erreur appropriés en cas de problèmes, tels que des paramètres manquants, l’absence de privilèges ou des chemins d’accès aux fichiers invalides.

Ce script offre un moyen puissant et simple de surveiller les fichiers texte, ce qui en fait un outil essentiel dans la boîte à outils des professionnels de l’informatique.

Cas d’utilisation potentiels

Imaginez un professionnel de l’informatique chargé de contrôler les journaux de sécurité de plusieurs serveurs. Il doit détecter les messages d’erreur spécifiques ou les tentatives d’accès non autorisé dès qu’elles se produisent.

En déployant ce script, il peut automatiser le processus d’analyse de ces fichiers journaux à la recherche de mots-clés critiques, tels que “unauthorized access” ou “erreur 503”. Chaque fois que ces mots-clés sont trouvés, le script les alerte immédiatement, ce qui permet de réagir rapidement aux menaces potentielles pour la sécurité. Cette approche proactive renforce la posture de sécurité de l’entreprise et réduit le risque de négliger des problèmes critiques.

Comparaisons

Par rapport à d’autres méthodes, telles que l’utilisation d’un logiciel tiers de gestion des journaux ou l’inspection manuelle des journaux, ce script PowerShell offre une solution légère et personnalisable. Si les outils tiers peuvent offrir davantage de fonctionnalités, ils ont souvent un coût et nécessitent une configuration supplémentaire.

D’autre part, l’inspection manuelle prend beaucoup de temps et est sujette à des erreurs humaines. Ce texte trouve un équilibre en fournissant une solution automatisée et rentable qui s’intègre parfaitement dans les flux de travail existants.

FAQ

1. Ce script peut-il être utilisé pour surveiller plusieurs fichiers simultanément ?

Non, ce script est conçu pour surveiller un seul fichier à la fois. Toutefois, vous pouvez modifier le script ou l’exécuter en parallèle pour plusieurs fichiers.

2. Que se passe-t-il si le fichier surveillé est mis à jour après l’exécution du script ?

Le script lit le contenu du fichier au moment de l’exécution. Si le fichier est mis à jour après le démarrage du script, ces modifications ne seront pas détectées à moins que le script ne soit réexécuté.

3. Est-il possible d’enregistrer les alertes dans un fichier au lieu de les afficher sur la console ?

Oui, vous pouvez modifier le script pour enregistrer les alertes dans un fichier en remplaçant Write-Host par Add-Content ou Out-File.

Implications

L’utilisation de ce script pour surveiller les fichiers critiques peut avoir des conséquences importantes pour la sécurité informatique. En automatisant la détection des phrases clés ou des messages d’erreur, les professionnels de l’informatique peuvent réagir plus rapidement aux problèmes potentiels, ce qui réduit les temps d’arrêt et atténue les risques de sécurité.

Cependant, il est important de se rappeler que ce script opère dans les limites du fichier texte spécifié et qu’il n’est aussi efficace que les mots-clés qu’il est configuré pour surveiller. S’il est utilisé correctement, il peut être un outil puissant dans la stratégie plus large de surveillance informatique et de réponse aux incidents.

Recommandations

Lors de l’utilisation de ce script, il est préférable de suivre les pratiques suivantes :

• Test dans un environnement contrôlé: Avant de déployer le script dans un environnement de production, testez-le dans un environnement contrôlé pour vous assurer qu’il se comporte comme prévu.
• Mettre régulièrement à jour les mots-clés: Examinez et mettez à jour les mots-clés que vous surveillez pour vous assurer qu’ils correspondent à l’évolution des menaces et des besoins opérationnels.
• Intégration avec d’autres outils: Envisagez d’intégrer le script à d’autres outils de surveillance ou systèmes d’alerte pour créer une solution de surveillance plus complète.

Conclusion

Pour les professionnels de l’informatique, en particulier ceux qui gèrent plusieurs environnements, l’automatisation est cruciale. Ce script PowerShell offre un moyen simple mais efficace de surveiller les fichiers texte à la recherche d’informations critiques, ce qui permet de réagir rapidement aux problèmes potentiels.

Bien que ce script soit un outil puissant en soi, il convient de noter que des solutions complètes de gestion informatique telles que NinjaOne peuvent encore améliorer votre capacité à surveiller, gérer et sécuriser vos systèmes. En combinant ces scripts avec une plateforme de gestion informatique plus étendue, vous pouvez vous assurer que l’infrastructure informatique de votre entreprise reste solide et résiliente.