Beispielskript für Enable-SecureBootUpdateTask.ps1

WICHTIG Dieser Artikel, der dieses Beispielskript enthält, wurde eingestellt. Ab den Windows-Updates, die am und nach dem 12. Mai 2026 veröffentlicht wurden, befindet sich das Beispielskript auf Ihrem Gerät im Ordner %systemroot%\SecureBoot\ExampleRolloutScripts .

<# . SYNOPSIS
    Aktiviert den geplanten Task "Secure Boot Update".

.DESCRIPTION     Dieses Skript stellt sicher, dass die geplante Aufgabe
"Windows Secure Boot Update" (Windows Secure Boot Update) geplant ist.     (\Microsoft\Windows\PI\Secure-Boot-Update) ist aktiviert. Wenn deaktiviert,
    sie aktiviert. Wenn die Aufgabe gelöscht wurde, kann sie neu erstellt werden.

.PARAMETER Action     Die auszuführende Aktion. Gültige Werte: überprüfen, aktivieren, erstellen
    - überprüfen: Überprüfen Sie nur die aufgabe status
    – aktivieren: (Standard) Aktivieren Sie die Aufgabe, wenn sie deaktiviert ist. Wenn der Task fehlt, wird zum Erstellen aufgefordert.
- create: Erstellen Sie die Aufgabe, wenn sie nicht vorhanden ist.

.PARAMETER ComputerName     Optional. Array von Computernamen, auf denen die Aufgabe überprüft/aktiviert werden soll.
Wenn nicht angegeben, wird auf dem lokalen Computer ausgeführt.

.PARAMETER Credential     Optional. Anmeldeinformationen für den Remotecomputerzugriff.

.PARAMETER Quiet     Unterdrückt Eingabeaufforderungen und antwortet automatisch auf Ja. Nützlich für die Automatisierung.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Aktiviert die aufgabe status auf dem lokalen Computer

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 enable
    # Aktiviert die Aufgabe, wenn sie deaktiviert ist. Prompts erstellen, wenn sie fehlen.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 create
    # Erstellt die Aufgabe, wenn sie gelöscht wurde, und überprüft dann ihre status

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Überprüft die Aufgabe auf Remotecomputern

.NOTES     Erfordert Administratorrechte zum Aktivieren oder Erstellen der Aufgabe.
Aufgabenpfad: \Microsoft\Windows\PI\Secure-Boot-Update
    Der Task wird alle 12 Stunden taskhostw.exe mit erhöhten Berechtigungen ausgeführt.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parameter(Position=0)]
    [ValidateSet('check', '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" # Hinweis: Dieses Skript wird auf Endpunkten ausgeführt, um den Task Secure Boot Update zu aktivieren.

$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
        Fehler = $null
    }

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            # Verwenden von schtasks.exe für eine zuverlässigere Aufgabenerkennung
            $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # Task not found is not an error - just means task does't exist
                $result. TaskExists = $false
                $result
zurückgeben             }
            
            # Analysieren der CSV-Ausgabe
            $taskData = $schtasksOutput | ConvertFrom-CSV
            if ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Versuchen Sie, die nächste Laufzeit aus den Daten
abzurufen.                 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 {
            # Remotecomputer – Verwenden von Invoke-Command mit schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Ausgabe = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Task not found is not an error - just means task does't exist
                $result. TaskExists = $false
                $result
zurückgeben             }

            $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. Fehler = $_. 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     # Verwendet ComHandler mit der SBServicing-Klasse, wird als LocalSystem
ausgeführt.     $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo->
    <Datum>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>
    <Beschreibung>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
 >
für <-Prinzipale     <Principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </Principal>
  </Principals>
  <>
    <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
  <triggers>
    <BootTrigger->
      <Delay>PT5M</Delay>
     >
<Wiederholungen         <interval>PT12H</Interval>
      </Wiederholungs
->     </BootTrigger->
  </Trigger>
  <Actions Context="LocalSystem">
    <ComHandler->
      <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <><! [CDATA[SBServicing]]></Data>
    </ComHandler->
  </Actions>
</Task>
" @

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Geplante Aufgabe erstellen")) {
                # Xml in temporärer Datei speichern und importieren
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Encoding 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", "Geplante Aufgabe erstellen")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($taskPath, $taskName, $xml)
                    $tempFile = [System.IO.Path]::GetTempFileName()
                    $xml | Out-File -FilePath $tempFile -Encoding Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Ausgabe = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Ausgabe -join " " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Erfolg = $success
        Fehler = $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", "Geplante Aufgabe aktivieren")) {
                $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", "Geplante Aufgabe aktivieren")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Ausgabe = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Ausgabe -join " " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Erfolg = $success
        Fehler = $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 "Checking: $computer" -ForegroundColor Yellow

    $status = Get-SecureBootTaskStatus -Computer $computer

    , wenn ($status. Fehler) {
        Write-Host " Fehler: $($status. Error)" -ForegroundColor Red
    }
    elseif (nicht $status. TaskExists) {
        Write-Host "Task ist auf diesem System nicht vorhanden" -ForegroundColor Red

        # Erstellen, falls angefordert, oder Eingabeaufforderung, wenn Aktivieren angegeben
wurde         $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host " Die Aufgabe wurde möglicherweise gelöscht." -ForegroundColor Yellow
            if ($Quiet) {
                Write-Host "Aufgabe automatisch erstellen (Ruhemodus)" -ForegroundColor Cyan
                $shouldCreate = $true
            } else {
                $confirm = Read-Host " Möchten Sie die Aufgabe neu erstellen?                    (Y/N)"
                if ($confirm -eq 'Y' -or $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }

        if ($shouldCreate) {
            Write-Host "Aufgabe wird erstellt..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask -Computer $computer

            if ($createResult.Success) {
                Write-Host "Aufgabe erfolgreich erstellt" -ForegroundColor Green
                # Status
erneut überprüfen                 $status = Get-SecureBootTaskStatus -Computer $computer

                , wenn ($status. TaskExists) {
                    $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
                    Write-Host " State: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host " Fehler beim Erstellen: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    else {
        $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
        Write-Host " State: $($status. TaskState)" -ForegroundColor $stateColor

        , wenn ($status. LastRunTime -und $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Letzte Ausführung: $($status. LastRunTime)" -ForegroundColor Gray
        }
        , wenn ($status. NextRunTime - und $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Nächste Ausführung: $($status. NextRunTime)" -ForegroundColor Gray
        }                                                

        # Enable if requested and currently disabled         if ($Enable -and -not $status. IsEnabled) {
            Write-Host "Aufgabe wird aktiviert..." -ForegroundColor Yellow
            $enableResult = Enable-SecureBootTask -Computer $computer

            if ($enableResult.Success) {
                Write-Host " Task erfolgreich aktiviert" -ForegroundColor Green
                # Status
erneut überprüfen                 $status = Get-SecureBootTaskStatus -Computer $computer
            }
            else {
                Write-Host " Fehler beim Aktivieren: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable -and $status. IsEnabled) {
            Write-Host " Task ist bereits aktiviert" -ForegroundColor Green
        }
    }

    $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 }). Count
$notFound = ($results | Where-Object { -not $_. TaskExists }). Count
$errors = ($results | Where-Object { $_. Fehler }). Count

Write-Host "Total Checked: $($results.Count)" Write-Host "Enabled: $enabled" -ForegroundColor Green
if ($disabled -gt 0) { Write-Host "Disabled: $disabled" -ForegroundColor Red }
if ($notFound -gt 0) { Write-Host "Nicht gefunden: $notFound" -ForegroundColor Yellow }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results