Przykładowy skrypt Enable-SecureBootUpdateTask.ps1

WAŻNE Ten artykuł zawierający ten przykładowy skrypt został wycofany. Począwszy od aktualizacji systemu Windows wydanych 12 maja 2026 r. i później, przykładowy skrypt znajduje się w folderze %systemroot%\SecureBoot\ExampleRolloutScripts na twoim urządzeniu.

<# . STRESZCZENIE
    Umożliwia zaplanowaną aktualizację bezpiecznego rozruchu.

.DESCRIPTION     Ten skrypt gwarantuje zaplanowaną
aktualizację bezpiecznego rozruchu systemu Windows     (\Microsoft\Windows\PI\Secure-Boot-Update) jest włączona. Jeśli ta funkcja jest wyłączona,
    umożliwia jej obsługę. Jeśli zadanie zostało usunięte, może je odtworzyć.

.PARAMETER Action     Akcja do wykonania. Prawidłowe wartości: sprawdzanie, włączanie, tworzenie
    - sprawdź: Sprawdzaj tylko stan
zadania     - włącz: (domyślnie) Włącz zadanie, jeśli jest wyłączone. Jeśli brakuje zadania, zostanie wyświetlony monit o utworzenie.
- utwórz: Utwórz zadanie, jeśli nie istnieje

.PARAMETER ComputerName     Opcjonalne. Tablica nazw komputerów do sprawdzenia/włączenia zadania.
Jeśli nie określono, działa na komputerze lokalnym.

.PARAMETER Credential     Opcjonalne. Poświadczenia dostępu do komputera zdalnego.

.PARAMETER Quiet     Pomija monity i automatycznie odpowiada tak. Przydaje się do automatyzacji.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Włącza stan zadania na komputerze lokalnym

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 włącz
    # Włącza zadanie, jeśli jest wyłączone. Polecenia utworzyć, jeśli go nie ma.

.EXAMPLE     tworzenie \Check-SecureBootScheduledTask.ps1
    # Tworzy zadanie, jeśli zostało usunięte, a następnie sprawdza jego stan

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 sprawdź -ComputerName "PC1", "PC2"
    # Sprawdza zadanie na komputerach zdalnych

.NOTES     Do włączenia lub utworzenia zadania są wymagane uprawnienia administratora.
Ścieżka zadania: \Microsoft\Windows\PI\Secure-Boot-Update
    Zadanie jest uruchamiane taskhostw.exe co 12 godzin z podwyższonym poziomem uprawnień.
#>

[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 "włącz"
$Create = $Action -eq "create"

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples" # Uwaga: Ten skrypt działa na punktach końcowych, aby włączyć zadanie aktualizacji bezpiecznego rozruchu.

$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
        Błąd = $null
    }

    try {         if ($Computer -eq $env:COMPUTERNAME -lub $Computer -eq "localhost" -lub $Computer -eq ""). {
            # Użyj schtasks.exe, aby uzyskać bardziej niezawodne wykrywanie
zadań             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                Nie można odnaleźć zadania nie jest błędem — oznacza tylko, że zadanie nie istnieje
                $wynik. TaskExists = $false
               
$result zwrotu             }
            
            # Parse csv output
            $taskData = $schtasksOutput | ConvertFrom-Csv
            if ($taskData) {
                $wynik. TaskExists = $true
                $wynik. TaskState = $taskData.Status
                $wynik. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Spróbuj uzyskać czas następnego uruchomienia z danych
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    wypróbuj {
                        $wynik. NextRunTime = [DateTime]::P arse($taskData.'Next Run Time')
                    } złapać { }
                }
            }
        }
        inaczej {
            # Komputer zdalny — używanie Invoke-Command z schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Dane wyjściowe = $output
                }
            } -Lista argumentów "$TaskPath$Nazwa_zadania" -Zatrzymanie akcji

            if ($remoteResult.ExitCode -ne 0) {                 Nie można odnaleźć zadania nie jest błędem — oznacza tylko, że zadanie nie istnieje
                $wynik. TaskExists = $false
                $result zwrotu
            }

            $taskData = $remoteResult.Output | ConvertFrom-Csv             if ($taskData) {
                $wynik. TaskExists = $true
                $wynik. TaskState = $taskData.Status
                $wynik. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
            }
        }
    }
    złapać {
        $wynik. Błąd = $_. 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     # Używa ComHandler z klasą SBServicing, działa jako LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Data>2012-02-07T16:39:20</Date>
    <SecurityDescriptor>O:BAG:BAD:P(A;; FA;;; BA)(A;; FA;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <>źródłowy "$(@%SystemRoot%\system32\TpmTasks.dll;-601)</>
źródłowy     <author>'$(@%SystemRoot%\system32\TpmTasks.dll;-600)</Author>
    <Description>'$(@%SystemRoot%\system32\TpmTasks.dll;-604)</Description>
    <URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
 >zleceniodawców <
    <id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </>
główne   </Principals>
 >ustawień <
    <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>
  <wyzwalaczy>
   >BootTrigger <
      <Opóźnienie><PT5M />
opóźnienia      ><
powtarzania <         interwał <><PT12H />
interwału       <
/>powtarzania     </BootTrigger>
  </Triggers>
  <Actions Context="LocalSystem">
   ><ComHandler
      <classId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <>< danych! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</>
zadań " @

    try {         if ($Computer -eq $env:COMPUTERNAME -lub $Computer -eq "localhost" -lub $Computer -eq ""). {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Zapisywanie pliku XML w pliku tymczasowym i importowanie
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Kodowanie 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
                } inaczej {
                    $errorMsg = $output -join " "
                }
            }
        }
        inaczej {
            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 -Kodowanie Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Dane wyjściowe = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } inaczej {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    złapać {
        $errorMsg = $_. Exception.message
    }

    return @{         Sukces = $success
        Błąd = $errorMsg
    }
}

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

    $success = $false     $errorMsg = $null

    try {         if ($Computer -eq $env:COMPUTERNAME -lub $Computer -eq "localhost" -lub $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
                } inaczej {
                    $errorMsg = $output -join " "
                }
            }
        }
        inaczej {
            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; Dane wyjściowe = $output }
                } -Lista argumentów "$TaskPath$TaskName" -Zatrzymanie
                
akcji                 if ($result. ExitCode -eq 0) {
                    $success = $true
                } inaczej {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    złapać {
        $errorMsg = $_. Exception.message
    }

    return @{         Sukces = $success
        Błąd = $errorMsg
    }
}

# Main execution Write-Host ""
Write-Host "========================================" -ForegroundColor Cyan
Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" — Pierwszy planColor Cyan
Write-Host ""
Write-Host "Zadanie: $TaskPath$TaskName" -Pierwszy planColor Gray
Write-Host ""

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

$results = @()

foreach ($computer in $targets) {     Write-Host "Checking: $computer" -ForegroundColor Yellow

    $status = $computer Get-SecureBootTaskStatus

-Komputer     if ($status. Błąd) {
        Write-Host " Błąd: $($status. Błąd)" -Pierwszy planKolorowanie koloru czerwonego
    }
    elseif (-nie $status. TaskExists) {
        Write-Host " Zadanie nie istnieje w tym systemie" -Pierwszy planKolor czerwony

        # Utwórz w razie potrzeby lub monituj, czy została określona
opcja Włącz         $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host " Zadanie mogło zostać usunięte." -ForegroundColor Yellow
            if ($Quiet) {
                Write-Host " Automatyczne tworzenie zadania (tryb cichy)" -ForegroundColor Cyan
                $shouldCreate = $true
            } inaczej {
                $confirm = Read-Host " Czy chcesz ponownie utworzyć zadanie?                    (Y/N)"
                if ($confirm -eq 'Y' -lub $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        if ($shouldCreate) {
            Write-Host " Creating task..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask — $computer komputerowe
            
            if ($createResult.Success) {
                Write-Host " Zadanie utworzone pomyślnie" -ForegroundColor Green
                # Sprawdź ponownie stan
                $status = $computer Get-SecureBootTaskStatus -Komputer
                
                if ($status. TaskExists) {
                    $stateColor = jeżeli ($status. IsEnabled) { "Green" } inaczej { "Red" }
                    Write-Host " Stan: $($status. TaskState)" -Pierwszy planKolor $stateColor
                }
            }
            inaczej {
                Write-Host " Nie można utworzyć: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    inaczej {
        $stateColor = jeżeli ($status. IsEnabled) { "Green" } inaczej { "Red" }
        Write-Host " Stan: $($status. TaskState)" -Pierwszy planKolor $stateColor
        
        if ($status. LastRunTime -i $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Ostatni bieg: $($status. LastRunTime)" -Pierwszy planKolor szary
        }
        if ($status. NextRunTime -i $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Next Run: $($status. NextRunTime)" -ForegroundColor Gray
        }

        # Enable if requested and currently disabled         if ($Enable -and -not $status. IsEnabled) {
            Write-Host "Włączanie zadania..." -Kolor pierwszego planuColor Yellow
            $enableResult = Enable-SecureBootTask -Komputer $computer

            if ($enableResult.Success) {
                Write-Host "Pomyślnie włączono zadanie" —Kolor pierwszego planuColor Green
                # Sprawdź ponownie stan
                $status = Get-SecureBootTaskStatus -$computer komputerowa
            }
            inaczej {
                Write-Host " Nie można włączyć: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable -i $status. IsEnabled) {
            Write-Host " Zadanie jest już włączone" -ForegroundColor Green
        }
    }

    $results += $status
    Write-Host ""
}                  

# Summary Write-Host "========================================" —Pierwszy planColor Cyan
Write-Host "Summary" -ForegroundColor Cyan
Write-Host "========================================" —Pierwszy planColor Cyan

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists -and -not $_. IsEnabled }). Liczba
$notFound = ($results | Where-Object { -not $_. TaskExists }). Liczba
$errors = ($results | Where-Object { $_. Błąd }). Liczba

Write-Host "Total Checked: $($results.Count)" Write-Host "Włączony: $enabled" —Pierwszy planColor Green
if ($disabled -gt 0) { Write-Host "Disabled: $disabled" -ForegroundColor Red }
if ($notFound -gt 0) { Write-Host "Nie znaleziono: $notFound" -Kolor pierwszego planu Żółty }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results