Ukázkový skript Enable-SecureBootUpdateTask.ps1

DŮLEŽITÉ Tento článek obsahující tento ukázkový skript byl vyřazen. Počínaje aktualizacemi Windows vydanými 12. května 2026 a po tomto období se ukázkový skript nachází ve složce %systemroot%\SecureBoot\ExampleRolloutScripts na vašem zařízení.

<# . SYNOPSE
    Povolí naplánovanou úlohu aktualizace zabezpečeného spouštění.

.DESCRIPTION     Tento skript zajišťuje naplánovanou úlohu
aktualizace zabezpečeného spouštění systému Windows.     (\Microsoft\Windows\PI\Secure-Boot-Update) je povolená. Pokud je zakázáno,
    to umožňuje. Pokud byl úkol odstraněn, může ho znovu vytvořit.

.PARAMETER Action     Akce, která se má provést. Platné hodnoty: check, enable, create
    – kontrola: Zkontrolujte pouze stav
úkolu.     – povolit: (výchozí) Povolte úlohu, pokud je zakázaná. Pokud úkol chybí, zobrazí výzvu k vytvoření.
- create: Vytvořte úlohu, pokud neexistuje.

.PARAMETER ComputerName     Volitelné. Pole názvů počítačů, které mají úkol zkontrolovat nebo povolit.
Pokud není zadaný, spustí se na místním počítači.

.PARAMETER Credential     Volitelné. Přihlašovací údaje pro přístup ke vzdálenému počítači.

.PARAMETER Quiet     Potlačí výzvy a automaticky odpoví Ano. Užitečné pro automatizaci.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Povolí stav úlohy na místním počítači.

.EXAMPLE     Povolit
.\Check-SecureBootScheduledTask.ps1     # Povolí úlohu, pokud je zakázaná. Výzvy, která se má vytvořit, pokud chybí.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 create
    # Vytvoří úlohu, pokud byla odstraněna, a pak zkontroluje její stav.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 zaškrtněte -ComputerName "PC1", "PC2"
    # Zkontroluje úlohu na vzdálených počítačích.

.NOTES     K povolení nebo vytvoření úlohy vyžaduje oprávnění správce.
Cesta úlohy: \Microsoft\Windows\PI\Secure-Boot-Update
    Úloha se spouští taskhostw.exe každých 12 hodin se zvýšenými oprávněními.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parametr(Pozice=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" # Poznámka: Tento skript se spustí na koncových bodech a povolí úlohu aktualizace zabezpečeného spouštění.

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

function Get-SecureBootTaskStatus {     [RutinaBinding()]
    param(
        [string]$Computer = $env:NÁZEV POČÍTAČE
    )

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

    try {         if ($Computer -eq $env:NÁZEV_POČÍTAČE -nebo $Computer -eq "localhost" -nebo $Computer -eq ".") {
            # Použití schtasks.exe pro spolehlivější detekci
úloh             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # Úkol nebyl nalezen není chyba – znamená to, že úkol neexistuje
.                 $result. TaskExists = $false
                vrácení $result
            }
            
            # Parsovat výstup
CSV             $taskData = $schtasksOutput | ConvertFrom-Csv
            if ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -nebo $taskData.Status -eq 'Running')
                
                # Zkuste z dat
získat čas příštího spuštění.                 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 {
            # Vzdálený počítač - použití Invoke-Command s schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Output = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Úkol nebyl nalezen není chyba – znamená to, že úkol neexistuje
.                 $result. TaskExists = $false
                return $result
            }

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

    return $result
}

function New-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [string]$Computer = $env:NÁZEV POČÍTAČE
    )

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Používá ComHandler s třídou SBServicing, spouští se 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     <Datum>2012-02-07T16:39:20</Date>
    <SecurityDescriptor>O:BAG:BAD:P(A;; DM;;; BA)(A;; DM;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <Zdrojová>$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <Author>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <Popis>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <identifikátor URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
 ></RegistrationInfo
 >
objektů zabezpečení <     <Principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </Principal>
 >
</Principals  >
nastavení <     <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   triggery <>
    <>
BootTrigger       <Delay>PT5M</Delay>
      <opakování>
        <Interval>PT12H</Interval>
      </Opakování>
   ></BootTrigger
  </Triggery>
  <Actions Context="LocalSystem">
   >
<ComHandler       <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <data><! [CDATA[SBServicing]]]></Data>
    </ComHandler>
 >
</Actions </Task>
" @

    try {         if ($Computer -eq $env:NÁZEV_POČÍTAČE -nebo $Computer -eq "localhost" -nebo $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Uložit XML do dočasného souboru a importovat
                $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", "Vytvořit naplánovanou úlohu")) {
                $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; Output = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Úspěch = $success
        Chyba = $errorMsg
    }
}

function Enable-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [string]$Computer = $env:NÁZEV POČÍTAČE
    )

    $success = $false     $errorMsg = $null

    try {         if ($Computer -eq $env:NÁZEV_POČÍTAČE -nebo $Computer -eq "localhost" -nebo $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", "Povolit naplánovanou úlohu")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Output = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Úspěch = $success
        Chyba = $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 "Kontrola: $computer" -ForegroundColor Yellow

    $status = Get-SecureBootTaskStatus -Computer $computer

    if ($status. Chyba) {
        Write-Host " Chyba: $($status. Chyba)" -ForegroundColor Red
    }
    elseif (-not $status. TaskExists) {
        Write-Host "Úkol v tomto systému neexistuje" -ForegroundColor Red

        # Vytvořit, pokud je požadováno, nebo dotázat se, pokud bylo zadáno
Povolení         $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host "Úkol byl pravděpodobně odstraněn." -ForegroundColor Yellow
            if ($Quiet) {
                Write-Host " Automatické vytváření úkolu (tichý režim)" -ForegroundColor azurová
                $shouldCreate = $true
            } else {
                $confirm = Read-Host " Chcete úkol znovu vytvořit?                    (A/N)"
                if ($confirm -eq 'Y' -nebo $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        if ($shouldCreate) {
            Write-Host "Vytváření úkolu..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask -Computer $computer
            
            if ($createResult.Success) {
                Write-Host "Úkol se úspěšně vytvořil" -ForegroundColor Green
                # Znovu zkontrolovat stav
                $status = Get-SecureBootTaskStatus -Computer $computer
                
                if ($status. TaskExists) {
                    $stateColor = když ($status. IsEnabled) { "Green" } else { "Red" }
                    Write-Host " Stav: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host "Nepodařilo se vytvořit: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    else {
        $stateColor = když ($status. IsEnabled) { "Green" } else { "Red" }
        Write-Host " Stav: $($status. TaskState)" -ForegroundColor $stateColor
        
        if ($status. LastRunTime a $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Poslední spuštění: $($status. LastRunTime)" -ForegroundColor Gray
        }
        if ($status. NextRunTime a $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Další spuštění: $($status. NextRunTime)" -ForegroundColor Gray
        }

        # Enable if requested and currently disabled         if ($Enable -a -not $status. IsEnabled) {
            Write-Host "Povolení úkolu..." -ForegroundColor Yellow
            $enableResult = Enable-SecureBootTask -Computer $computer

            if ($enableResult.Success) {
                Write-Host "Úloha byla úspěšně povolena" -ForegroundColor Green
                # Znovu zkontrolovat stav
                $status = Get-SecureBootTaskStatus -Computer $computer
            }
            else {
                Write-Host "Nepovedlo se povolit: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable a $status. IsEnabled) {
            Write-Host "Úkol je už povolený" –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 }). Počet
$notFound = ($results | Where-Object { -not $_. TaskExists }). Počet
$errors = ($results | Where-Object { $_. Chyba }). Počet

Write-Host "Total Checked: $($results.Count)" Write-Host "Povoleno: $enabled" -ForegroundColor Green
if ($disabled -gt 0) { Write-Host "Zakázáno: $disabled" -ForegroundColor Red }
if ($notFound -gt 0) { Write-Host "Nenalezena: $notFound" -ForegroundColor Yellow }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results