Vzorový Enable-SecureBootUpdateTask.ps1 skript

DÔLEŽITÉ Tento článok obsahujúci tento vzorový skript bol vyradený. Počnúc aktualizáciami Windowsu vydanými 12. mája 2026 a neskôr sa vzorový skript nachádza v priečinku %systemroot%\SecureBoot\ExampleRolloutScripts vo vašom zariadení.

<# . PREHĽADU
    Umožňuje naplánovať úlohu aktualizácie zabezpečeného spustenia.

.DESCRIPTION     Tento skript zabezpečí, že plánovaná úloha
aktualizácie zabezpečeného spustenia systému Windows     (\Microsoft\Windows\PI\Secure-Boot-Update) je povolené. Ak je vypnutá,
    umožňuje. Ak bola úloha odstránená, môže ju znova vytvoriť.

.PARAMETER Action     Akcia, ktorá sa má vykonať. Platné hodnoty: kontrola, povolenie, vytvorenie
    - kontrola: Kontrolovať iba stav
úlohy     - povoliť: (predvolené) Ak je úloha vypnutá, povoľte ju. Ak úloha chýba, zobrazí sa výzva na vytvorenie.
- create: Vytvorte úlohu, ak neexistuje

.PARAMETER ComputerName     Voliteľné. Pole názvov počítačov na kontrolu/povolenie úlohy.
Ak nie je zadané, spustí sa v lokálnom počítači.

.PARAMETER Credential     Voliteľné. Poverenia pre vzdialený prístup k počítaču.

.PARAMETER Quiet     Potlačí výzvy a automaticky odpovie áno. Užitočné pre automatizáciu.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Umožňuje stav úlohy v lokálnom počítači

.EXAMPLE     Povolenie .\Check-SecureBootScheduledTask.ps1
    # Povolí úlohu, ak je zakázaná. Príkazy vytvoriť, ak chýba.

.EXAMPLE     Vytvoriť .\Check-SecureBootScheduledTask.ps1
    # Vytvorí úlohu, ak bola odstránená, a potom skontroluje jej stav

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Skontroluje úlohu na vzdialených počítačoch

.NOTES     Vyžaduje oprávnenia správcu na povolenie alebo vytvorenie úlohy.
Cesta k úlohe: \Microsoft\Windows\PI\Secure-Boot-Update
    Úloha sa spúšťa taskhostw.exe každých 12 hodín so zvýšenými oprávneniami.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parameter(Pozícia=0)]
    [ValidateSet('check', 'enable', 'create', '')]
    [reťazec]$Action = "enable",

    [Parameter()]     [reťazec[]]$ComputerName,

    [Parameter()]     [PSCredential]$Credential,

    [Parameter()]     [Alias('Force', 'Silent')]
    [prepínač]$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 sa spúšťa na koncových bodoch na povolenie úlohy aktualizácie zabezpečeného spustenia.

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

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

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

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            # Použitie schtasks.exe na spoľahlivejšie zisťovanie
úloh             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # Úloha sa nenašla, nie je chyba – znamená to len, že úloha neexistuje
                $result. TaskExists = $false
                vrátenie $result
            }
            
            # Analyzovať CSV výstup
            $taskData = $schtasksOutput | Konvertovať Z-Csv
            ak ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Pokúste sa získať čas ďalšieho spustenia z údajov
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    vyskúšať {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Next Run Time')
                    } chytiť { }
                }
            }
        }
        else {
            # Vzdialený počítač – použite Invoke-Command s úlohami
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Výstup = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Úloha sa nenašla, nie je chyba – znamená to len, že úloha neexistuje
                $result. TaskExists = $false
                vrátenie $result
            }

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

    return $result
}

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

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Používa ComHandler s triedou SBServicing, funguje ako LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Dátum>2012-02-07T16:39:20</Dátum>
    <SecurityDescriptor>O:BAG:BAD:P(A;; DM;;; BA)(A;; DM;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <zdrojový>$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Zdrojový>
    <autor>$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Autor>
    <popis>$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
  <principals>
    <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>
 >spúšťačov
<     <BootTrigger>
      <</Oneskorenie>PT5M>
     >opakovania <
       </Interval>PT12H><interval
      </Opakovanie>
    </BootTrigger>
  </Triggers>
  <Actions Context="LocalSystem">
    <ComHandler>
      <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <>< údajov! [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")) {
                # Uložiť XML do dočasného súboru a importovať
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Kódovanie 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 -Kódovanie Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Výstup = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                ak ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Výstup -join " "
                }
            }
        }
    }
    chytiť {
        $errorMsg = $_. Exception.Message
    }

    return @{         Success = $success
        Chyba = $errorMsg
    }
}

function Enable-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [reťazec]$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; Výstup = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                ak ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Výstup -join " "
                }
            }
        }
    }
    chytiť {
        $errorMsg = $_. Exception.Message
    }

    return @{         Success = $success
        Chyba = $errorMsg
    }
}

# Main execution Write-Host ""
Write-Host "========================================" -Azúrová
farba popredia Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" -Azúrová
farba popredia 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

    ak ($status. Chyba) {
        Write-Host " Chyba: $($status. Error)" -ForegroundColor Red
    }
    elseif (-nie $status. TaskExists) {
        Write-Host " Úloha neexistuje v tomto systéme" -ForegroundColor Red

        # Vytvoriť v prípade požiadavky alebo zobraziť výzvu, ak bolo zadané
povolenie         $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host Úloha bola pravdepodobne odstránená. -Farba popredia žltá
            ak ($Quiet) {
                Write-Host " Úloha automatického vytvárania (tichý režim)" -Azúrová
farba popredia                 $shouldCreate = $true
            } else {
                $confirm = Read-Host " Chcete úlohu znova vytvoriť?                    (Y/N)"
                if ($confirm -eq 'Y' -or $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        ak ($shouldCreate) {
            Write-Host " Creating task..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask -Computer $computer
            
            if ($createResult.Success) {
                Write-Host " Úloha sa úspešne vytvorila" -Farba popredia – zelená
                # Znova skontrolovať stav
                $status = Get-SecureBootTaskStatus -Computer $computer
                
                ak ($status. TaskExists) {
                    $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
                    Write-Host " State: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host " Nepodarilo sa vytvoriť: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    else {
        $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
        Write-Host " Štát: $($status. TaskState)" -ForegroundColor $stateColor
        
        ak ($status. LastRunTime a $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Last Run: $($status. LastRunTime)" -ForegroundColor Gray
        }
        ak ($status. NextRunTime a $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Ďalšie spustenie: $($status. NextRunTime)" -Farba popredia Sivá
        }

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

            if ($enableResult.Success) {
                Write-Host "Úloha bola úspešne povolená" -Farba popredia – zelená
                # Znova skontrolovať stav
                $status = Get-SecureBootTaskStatus -Computer $computer
            }
            else {
                Write-Host " Nepodarilo sa povoliť: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable - a $status. IsEnabled) {
            Write-Host " Úloha je už povolená" -Farba popredia – zelená
        }
    }

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

# Summary Write-Host "========================================" -Azúrová
farba popredia Write-Host " Summary" -ForegroundColor Azúrová
Write-Host "========================================" -Azúrová farba popredia

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists -a -nie $_. IsEnabled }). Počítať
$notFound = ($results | Where-Object { -not $_. TaskExists }). Počítať
$errors = ($results | Where-Object { $_. Chyba }). Počítať

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 "Not Found: $notFound" -ForegroundColor Yellow }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results