Exemple de script Enable-SecureBootUpdateTask.ps1

<# . SYNOPSIS
    Active la tâche planifiée de mise à jour de démarrage sécurisé.

.DESCRIPTION     Ce script garantit la tâche
planifiée de mise à jour de démarrage sécurisé Windows     (\Microsoft\Windows\PI\Secure-Boot-Update) est activé. Si cette option est désactivée,
    il l’active. Si la tâche a été supprimée, elle peut la recréer.

.PARAMETER Action     Action à effectuer. Valeurs valides : case activée, activer, créer
    - case activée : uniquement case activée la tâche status
    - enable : (par défaut) Activer la tâche si désactivée. Si la tâche est manquante, invite à créer.
- create : créer la tâche si elle n’existe pas

.PARAMETER ComputerName     Optionnel. Tableau de noms d’ordinateurs à case activée/activer la tâche.
S’il n’est pas spécifié, s’exécute sur l’ordinateur local.

.PARAMETER Credential     Optionnel. Informations d’identification pour l’accès aux ordinateurs distants.

.PARAMETER Quiet     Supprime les invites et répond automatiquement à Oui. Utile pour l’automatisation.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Active la tâche status sur l’ordinateur local

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 activer
    # Active la tâche si elle est désactivée. Requêtes à créer s’il est manquant.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 create
    # Crée la tâche si elle a été supprimée, puis vérifie son status

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 case activée -ComputerName « PC1 », « PC2 »
    # Vérifie la tâche sur les ordinateurs distants

.NOTES     Nécessite des privilèges d’administrateur pour activer ou créer la tâche.
Chemin de la tâche : \Microsoft\Windows\PI\Secure-Boot-Update
    La tâche s’exécute taskhostw.exe toutes les 12 heures avec des privilèges élevés.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Paramètre(Position=0)]
    [ValidateSet('case activée', 'enable', 'create', '')]
    [string]$Action = 'enable',

    [Parameter()]     [string[]]$ComputerName,

    [Parameter()]     [PSCredential]$Credential,

    [Parameter()]     [Alias('Force', 'Silent')]
    [switch]$Quiet
)

# Convert Action to switches for backward compatibility $Enable = $Action -eq 'enable'
$Create = $Action -eq 'create'

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples" # Remarque : ce script s’exécute sur des points de terminaison pour activer la tâche de mise à jour du démarrage sécurisé.

$TaskPath = "\Microsoft\Windows\PI\" $TaskName = « Secure-Boot-Update »

function Get-SecureBootTaskStatus {     [CmdletBinding()]
    param(
        [string]$Computer = $env :COMPUTERNAME
    )

    $result = [PSCustomObject]@{         ComputerName = $Computer
        TaskExists = $false
        TaskState = $null
        IsEnabled = $false
        LastRunTime = $null
        NextRunTime = $null
        Erreur = $null
    }

    try {         if ($Computer -eq $env :COMPUTERNAME -or $Computer -eq « localhost » -or $Computer -eq « . ») {
            # Utiliser schtasks.exe pour une détection
de tâche plus fiable             $schtasksOutput = schtasks.exe /Query /TN « $TaskPath$TaskName » /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # La tâche introuvable n’est pas une erreur. Signifie simplement que la tâche n’existe
pas                 $result. TaskExists = $false
                $result
de retour             }
            
            # Analyser la sortie
CSV             $taskData = $schtasksOutput | ConvertFrom-CSV
            if ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Essayer d’obtenir l’heure de la prochaine exécution à partir des données
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    try {
                        $result. NextRunTime = [DateTime] ::P arse($taskData.'Next Run Time')
                    } catch { }
                }
            }
        }
        else {
            # Ordinateur distant : utiliser Invoke-Command avec schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Sortie = $output
                }
            } -ArgumentList « $TaskPath$TaskName » -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # La tâche introuvable n’est pas une erreur. Signifie simplement que la tâche n’existe
pas                 $result. TaskExists = $false
                retour $result
            }

            $taskData = $remoteResult.Output | ConvertFrom-Csv             if ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
            }
        }
    }
    catch {
        $result. Erreur = $_. Exception.Message
    }

    return $result
}

function New-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [string]$Computer = $env :COMPUTERNAME
    )

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Utilise ComHandler avec la classe SBServicing, s’exécute en tant que LocalSystem
    $taskXml = @"
< ?xml version="1.0 » encoding="UTF-16 » ?>
<Task version="1.6 » xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <>RegistrationInfo
    <Date>2012-02-07T16:39:20</Date>
    <SecurityDescriptor>O :BAG :BAD :P(A ;; FA;;; BA)(A ;; FA;;; SY)(A ;; FRFX ;;; LS)</SecurityDescriptor>
    <source>'$(@ %SystemRoot %\system32\TpmTasks.dll,-601)</Source>
    <Author>'$(@ %SystemRoot %\system32\TpmTasks.dll,-600)</Author>
    <Description>'$(@ %SystemRoot %\system32\TpmTasks.dll,-604)</Description>
    URI <>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  <>/RegistrationInfo
 >principaux de <
    <Principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    <>/Principal
  <>/Principals
  <Paramètres>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <StartWhenAvailable>true</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    <>/IdleSettings
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
  </Settings>
 >déclencheurs <
   >BootTrigger
<       <retard><PT5M /Delay>
      <répétition>
        <Interval>PT12H</Interval>
      </Répétition>
    <>/BootTrigger
  <>/Triggers
  <Actions Context="LocalSystem">
    <>
ComHandler       <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <>< de données ! [CDATA[SBServicing]]></Data>
    <>/ComHandler
  </Actions>
</Task>
" @

    try {         if ($Computer -eq $env :COMPUTERNAME -or $Computer -eq « localhost » -or $Computer -eq « . ») {
            if ($PSCmdlet.ShouldProcess(« $TaskPath$TaskName », « Create scheduled task »)) {
                # Enregistrer du code XML dans un fichier temporaire et importer
                $tempFile = [System.IO.Path] ::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Encodage Unicode -Force
                
                $output = schtasks.exe /Create /TN « $TaskPath$TaskName » /XML $tempFile /F 2>&1
                
                Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                
                if ($LASTEXITCODE -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $output -join " »
                }
            }
        }
        else {
            if ($PSCmdlet.ShouldProcess(« $Computer\$TaskPath$TaskName », « Create scheduled task »)) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($taskPath, $taskName, $xml)
                    $tempFile = [System.IO.Path] ::GetTempFileName()
                    $xml | Out-File -FilePath $tempFile -Encodage Unicode -Force
                    $output = schtasks.exe /Create /TN « $taskPath$taskName » /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE ; Sortie = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Sortie -join " " »
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Réussite = $success
        Erreur = $errorMsg
    }
}

function Enable-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [string]$Computer = $env :COMPUTERNAME
    )

    $success = $false     $errorMsg = $null

    try {         if ($Computer -eq $env :COMPUTERNAME -or $Computer -eq « localhost » -or $Computer -eq « . ») {
            if ($PSCmdlet.ShouldProcess(« $TaskPath$TaskName », « Enable scheduled task »)) {
                $output = schtasks.exe /Change /TN « $TaskPath$TaskName » /ENABLE 2>&1
                if ($LASTEXITCODE -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $output -join " " »
                }
            }
        }
        else {
            if ($PSCmdlet.ShouldProcess(« $Computer\$TaskPath$TaskName », « Enable scheduled task »)) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE ; Sortie = $output }
                } -ArgumentList « $TaskPath$TaskName » -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Sortie -join " " »
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Réussite = $success
        Erreur = $errorMsg
    }
}

# Main execution Write-Host «  »
Write-Host « ======================================== » -ForegroundColor Cyan
Write-Host « Secure Boot Update Task Enabler » -ForegroundColor Cyan
Write-Host « ======================================== » -ForegroundColor Cyan
Write-Host «  »
Write-Host « Task : $TaskPath$TaskName » -ForegroundColor Gray
Write-Host «  »

# Determine target computers $targets = if ($ComputerName) { $ComputerName } else { @($env :COMPUTERNAME) }

$results = @()

foreach ($computer in $targets) {     Write-Host « Vérification : $computer » -ForegroundColor Yellow

    $status = Get-SecureBootTaskStatus -$computer

ordinateur     si ($status. Erreur) {
        Write-Host " Erreur : $($status. Erreur)" -ForegroundColor Red
    }
    elseif (-pas $status. TaskExists) {
        Write-Host « La tâche n’existe pas sur ce système » -ForegroundColor Red

        # Créer si demandé, ou demander si Activer a été spécifié
        $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host «  »
            Write-Host « La tâche a peut-être été supprimée ». -ForegroundColor Yellow
            if ($Quiet) {
                Write-Host « Tâche de création automatique (mode silencieux) » -ForegroundColor Cyan
                $shouldCreate = $true
            } else {
                $confirm = Read-Host « Voulez-vous recréer la tâche ?                    (Y/N)"
                if ($confirm -eq 'Y' -or $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }

        if ($shouldCreate) {
            Write-Host « Création d’une tâche... » -ForegroundColor Yellow
            $createResult = New-SecureBootTask -$computer de l’ordinateur

            if ($createResult.Success) {
                Write-Host « Tâche créée avec succès » -ForegroundColor Vert
                # Re-case activée status
                $status = Get-SecureBootTaskStatus -$computer

ordinateur                 si ($status. TaskExists) {
                    $stateColor = if ($status. IsEnabled) { « Green » } else { « Red » }
                    Write-Host " État : $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host « Échec de la création : $($createResult.Error) » -ForegroundColor Rouge
            }
        }
    }
    else {
        $stateColor = if ($status. IsEnabled) { « Green » } else { « Red » }
        Write-Host " État : $($status. TaskState)" -ForegroundColor $stateColor

        si ($status. LastRunTime -et $status. LastRunTime -ne [DateTime] ::MinValue) {
            Write-Host " Dernière exécution : $($status. LastRunTime)" -ForegroundColor Gray
        }
        si ($status. NextRunTime -et $status. NextRunTime -ne [DateTime] ::MinValue) {
            Write-Host " Prochaine exécution : $($status. NextRunTime)" -ForegroundColor Gray
        }                                                

        # Enable if requested and currently disabled         si ($Enable -et -pas $status. IsEnabled) {
            Write-Host « Activation de la tâche... » -ForegroundColor Yellow
            $enableResult = Enable-SecureBootTask -$computer

ordinateur             if ($enableResult.Success) {
                Write-Host « Tâche activée avec succès » -ForegroundColor Vert
                # Re-case activée status
                $status = Get-SecureBootTaskStatus -$computer
ordinateur             }
            else {
                Write-Host « Échec de l’activation : $($enableResult.Error) » -ForegroundColor Rouge
            }
        }
        elseif ($Enable -et $status. IsEnabled) {
            Write-Host « La tâche est déjà activée » -ForegroundColor Vert
        }
    }

    $results += $status
    Write-Host «  »
}                  

# Summary Write-Host « ======================================== » -ForegroundColor Cyan
Write-Host " Summary » -ForegroundColor Cyan
Write-Host « ======================================== » -ForegroundColor Cyan

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists -and -not $_. IsEnabled }). Compter
$notFound = ($results | Where-Object { -not $_. TaskExists }). Compter
$errors = ($results | Where-Object { $_. Erreur }). Compter

Write-Host "Total Checked: $($results.Count)" Write-Host « Activé : $enabled » -ForegroundColor Vert
if ($disabled -gt 0) { Write-Host « Disabled : $disabled » -ForegroundColor Red }
if ($notFound -gt 0) { Write-Host « Not Found : $notFound » -ForegroundColor Yellow }
if ($errors -gt 0) { Write-Host « Errors : $errors » -ForegroundColor Red }

# Return results for pipeline $results