Gestion des certificats : Maîtriser les alertes d’expiration de certificats avec PowerShell pour une sécurité informatique renforcée

Points à retenir

• Alertes automatisées: Le script fournit des alertes automatiques pour les certificats proches de l’expiration.
• Paramètres personnalisables: Les utilisateurs peuvent définir des paramètres pour les délais d’expiration et l’exclusion des certificats auto-signés.
• Sécurité renforcée: Des alertes opportunes permettent de maintenir la sécurité en évitant les vulnérabilités liées aux certificats expirés.
• Compatibilité et exigences: Prend en charge Windows 7 et Server 2008, avec des exigences spécifiques en matière de version de PowerShell et de privilèges.
• Évolutivité : Plus évolutif et personnalisable que les outils de gestion des certificats basés sur une interface graphique.
• Conformité proactive: Contribuer au maintien de la conformité en veillant à ce que les certificats soient renouvelés à temps.
• Intégration avec les outils MSP: Peut être intégré à des solutions MSP telles que NinjaOne pour une gestion informatique complète.  

La gestion des certificats numériques est un aspect crucial de la sécurité informatique et de la conformité. Ne pas tenir compte de l’expiration d’un certificat peut entraîner des risques de sécurité importants, des pannes de système et une perte de confiance. Une approche proactive de la gestion des certificats est essentielle pour maintenir l’intégrité et la fiabilité des systèmes informatiques.

Contexte

Ce script PowerShell est un outil polyvalent pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP). Il alerte les utilisateurs sur les certificats locaux proches de l’expiration, avec des options permettant d’ignorer les certificats auto-signés, expirés depuis longtemps ou à très court terme. Ce script est particulièrement utile dans les environnements où l’expiration du certificat peut entraîner des perturbations ou des failles de sécurité.  

Le script :

<#
.SYNOPSIS
    Alerts when a local certificate will expire in a configurable number of days. Can optionally ignore self-signed certificates, certificates that have been expired for a long time and certificates that were only valid for an extremely short time frame.
.DESCRIPTION
    Alerts when a local certificate will expire in a configurable number of days. 
    Can optionally ignore self-signed certificates, certificates that have been expired for a long time 
    and certificates that were only valid for an extremely short time frame.
.EXAMPLE
    (No Parameters)
    
    Checking for certificates that were valid before 10/10/2023 09:07:23 and will expire before 11/11/2023 09:07:23.
    No Certificates were found with an expiration date before 11/11/2023 09:07:23 and after 07/13/2023 09:07:23.

PARAMETER: -DaysUntilExpiration "ReplaceWithNumber"
    Alerts if a certificate is set to expire within the specified number of days.
.EXAMPLE
    -DaysUntilExpiration "366"
    
    Checking for certificates that were valid before 10/10/2023 09:08:14 and will expire before 10/12/2024 09:08:14.

    WARNING: Expired Certificates found!

    ### Expired Certificates ###

    SerialNumber                     HasPrivateKey ExpirationDate        Subject
    ------------                     ------------- --------------        -------
    0AA60783EBB5076EBC2D12DA9B04C290         False 6/10/2024 4:59:59 PM  CN=Insecure.Com LLC, O=Insecure.Com...
    619DCC976458E38D471DC3DCE3603C2C          True 3/29/2024 10:19:00 AM CN=KYLE-SRV22-TEST.test.lan
    0AA60783EBB5076EBC2D12DA9B04C290         False 6/10/2024 4:59:59 PM  CN=Insecure.Com LLC, O=Insecure.Com...
    7D5FC733E3A8CF9344CDDFC0AB01CCB9          True 4/9/2024 9:53:53 AM   CN=KYLE-SRV22-TEST.test.lan
    4EDC0A79D6CD5A8D4D1E3705BC20C206          True 4/9/2024 9:58:06 AM   CN=KYLLE-SRV22-TEST.test.lan

PARAMETER: -MustBeValidBefore "ReplaceWithNumber"
    Only alert on certificates that are older than X days. This is primarily to silence alerts about certificates that were only valid for 24 hours in their entire lifetime.

PARAMETER: -Cutoff "ReplaceWithNumber"
    Don't alert on certificates that have been expired for longer than X days (default is 91 days).

PARAMETER: -IgnoreSelfSignedCerts
    Ignore certificates where the subject of the certificate and the issuer of the certificate are identical.

.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Server 2008
    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/fr/conditions-dutilisation
    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]$ExpirationFromCustomField = "certExpirationAlertDays",
    [Parameter()]
    [int]$DaysUntilExpiration = 30,
    [Parameter()]
    [int]$MustBeValidBefore = 2,
    [Parameter()]
    [int]$Cutoff = 91,
    [Parameter()]
    [Switch]$IgnoreSelfSignedCerts = [System.Convert]::ToBoolean($env:ignoreSelfSignedCerts)
)
begin {
    # Retrieve script variables from the dynamic script form.
    if ($env:expirationFromCustomFieldName -and $env:expirationFromCustomFieldName -notlike "null") { $ExpirationFromCustomField = $env:expirationFromCustomFieldName }
    if ($env:daysUntilExpiration -and $env:daysUntilExpiration -notlike "null") { $DaysUntilExpiration = $env:daysUntilExpiration }
    if ($env:certificateMustBeOlderThanXDays -and $env:certificateMustBeOlderThanXDays -notlike "null") { $MustBeValidBefore = $env:certificateMustBeOlderThanXDays }
    if ($env:skipCertsExpiredForMoreThanXDays -and $env:skipCertsExpiredForMoreThanXDays -notlike "null") { $Cutoff = $env:skipCertsExpiredForMoreThanXDays }

    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 using the custom field option, check for the default value and replace it if necessary.
    if ($PSVersionTable.PSVersion.Major -gt 2) {
        $CustomField = Ninja-Property-Get -Name $ExpirationFromCustomField 2>$Null
    }

    if ($CustomField -and $DaysUntilExpiration -eq 30 -and (Test-IsElevated) -and $PSVersionTable.PSVersion.Major -gt 2) {
        Write-Host "Retrieved value of $CustomField days from Custom Field $ExpirationFromCustomField. Using it for expiration value."
        $DaysUntilExpiration = $CustomField
    }
    elseif (-not (Test-IsElevated) -or $PSVersionTable.PSVersion.Major -le 2) {
        Write-Warning "Skipping CustomField retrieval due to either incompatible PowerShell version or lack of elevation."
    }
}
process {
    # Calculate expiration and cutoff dates.
    $ExpirationDate = (Get-Date "11:59pm").AddDays($DaysUntilExpiration)
    $CutoffDate = (Get-Date "12am").AddDays(-$Cutoff)
    $MustBeValidBeforeDate = (Get-Date "12am").AddDays(-$MustBeValidBefore)

    # Retrieve all certificates.
    $Certificates = Get-ChildItem -Path "Cert:\" -Recurse

    Write-Host "Checking for certificates that were valid before $MustBeValidBeforeDate and will expire before $ExpirationDate."
    
    # Filter down to certificates that are expired in our desired date range
    $ExpiredCertificates = $Certificates | Where-Object { $_.NotAfter -le $ExpirationDate -and $_.NotAfter -gt $CutoffDate -and $_.NotBefore -lt $MustBeValidBeforeDate }

    # If we're asked to ignore self signed certs we'll filter them out
    if ($IgnoreSelfSignedCerts -and $ExpiredCertificates) {
        Write-Host "Removing Self-Signed certificates from list."
        $ExpiredCertificates = $ExpiredCertificates | Where-Object { $_.Subject -ne $_.Issuer }
    }

    if ($ExpiredCertificates) {
        Write-Host ""
        Write-Warning "Expired Certificates found!"
        Write-Host ""

        $Report = $ExpiredCertificates | ForEach-Object {
            # Subject can be a long property, we'll truncate it to maintain readability
            New-Object PSObject -Property @{
                SerialNumber   = $_.SerialNumber
                HasPrivateKey  = $_.HasPrivateKey
                ExpirationDate = $_.NotAfter
                Subject        = if ($_.Subject.Length -gt 35) { $_.Subject.Substring(0, 35) + "..." }else { $_.Subject }
            }
        }

        Write-Host "### Expired Certificates ###"
        $Report | Format-Table -AutoSize | Out-String | Write-Host

        exit 1
    }
    else {
        Write-Host "No Certificates were found with an expiration date before $ExpirationDate and after $CutoffDate."
    }
}
end {
    
    
    
}

 

Description détaillée

Le script fonctionne en plusieurs étapes distinctes :

• Initialisation : Il commence par définir des paramètres par défaut, tels que le nombre de jours avant l’expiration du certificat et divers seuils. Elles peuvent être remplacées par des variables d’environnement.
• Contrôles de l’environnement: Le script vérifie les privilèges nécessaires et la compatibilité de la version de PowerShell, et adapte son comportement en conséquence.
• Traitement des données: Il récupère tous les certificats du magasin local et les filtre en fonction de l’expiration, de la période de validité et du fait qu’ils soient ou non auto-signés, selon les paramètres fournis.
• Rapport: Si des certificats expirés sont trouvés, il génère un rapport énumérant leurs détails, sinon, il indique qu’aucun certificat concerné n’a été trouvé.

Des aides visuelles telles que des organigrammes peuvent illustrer efficacement ces étapes et rendre le processus plus compréhensible.

Cas d’utilisation potentiels

Prenons l’exemple d’un MSP qui supervise l’infrastructure informatique d’une organisation. Ils déploient ce script pour rechercher régulièrement les certificats proches de l’expiration. Ce système d’alerte précoce permet d’effectuer les renouvellements en temps voulu, évitant ainsi les interruptions de service ou les failles de sécurité.

Comparaisons

Cette approche PowerShell est plus personnalisable et mieux intégrée que les outils de gestion des certificats basés sur une interface graphique. Il permet l’automatisation et est plus évolutif pour les grandes entreprises que les contrôles manuels.

FAQ

• Comment le script détermine-t-il les certificats qui doivent faire l’objet d’une alerte ?
  Le script utilise des paramètres tels que la date d’expiration, la période de validité et le statut auto-signé pour filtrer les certificats.
• Ce script peut-il être exécuté sur n’importe quelle machine Windows ?
  Il est compatible avec Windows 7 et Server 2008, mais nécessite certains privilèges et certaines versions de PowerShell pour fonctionner pleinement.
• Est-il possible de personnaliser les critères d’alerte ?
  Oui, le script permet de personnaliser des paramètres tels que le nombre de jours jusqu’à l’expiration et les périodes de coupure.

Implications

Le non-renouvellement des certificats peut entraîner des failles de sécurité et une perte de confiance de la part des clients. Ce script permet de maintenir une posture de sécurité optimale en gérant de manière proactive les renouvellements de certificats.

Recommandations

• Planifiez régulièrement l’exécution du script, afin de garantir des alertes en temps utile.
• Personnalisez les paramètres pour répondre aux besoins spécifiques de votre environnement informatique.
• Veillez à ce que les privilèges et les paramètres de l’environnement soient appropriés pour une exécution correcte.

Conclusion :

Dans le cadre d’une gestion informatique globale, des outils tels que NinjaOne peuvent accroître les capacités de ce script. NinjaOne propose des solutions intégrées qui peuvent fonctionner avec de tels scripts pour rationaliser les opérations informatiques, renforcer la sécurité et garantir la conformité.