Enable-SecureBootUpdateTask.ps1 skripti näidis

OLULINE Seda näidisskripti sisaldav artikkel on kasutuselt kõrvaldatud. Alates Windowsi värskendustest, mis on välja antud 12. mail 2026 ja pärast seda, asub näidisskript teie seadme kaustas %systemroot%\SecureBoot\ExampleRolloutScripts .

<# . SÜNOPSIS
    Lubab secure Boot Update'i ajastatud toimingu.

.DESCRIPTION     See skript tagab Windowsi turvalise algkäivituse värskenduse ajastatud toimingu
    (\Microsoft\Windows\PI\Secure-Boot-Update) on lubatud. Kui see on keelatud,
    see lubab selle. Kui tööülesanne on kustutatud, saab selle uuesti luua.

.PARAMETER Action     Sooritatav toiming. Sobivad väärtused: kontrollimine, lubamine, loomine
    - kontroll: kontrollige ainult tööülesande olekut
    - enable: (vaikimisi) Lubage ülesanne, kui see on keelatud. Kui ülesanne puudub, palutakse see luua.
- loomine: looge tööülesanne, kui seda pole olemas

.PARAMETER ComputerName     Vabatahtlik. Arvutinimede massiiv, mille puhul ülesannet kontrollida/lubada.
Kui seda pole määratud, töötab see kohalikus arvutis.

.PARAMETER Credential     Vabatahtlik. Kaugarvuti juurdepääsu identimisteave.

.PARAMETER Quiet     Tõkestab viibad ja annab automaatselt vastuse Jah. Kasulik automatiseerimiseks.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Lubab tööülesande oleku kohalikus arvutis

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 lubamine
    # Lubab ülesande, kui see on keelatud. Juhised luua, kui see puudub.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 loomine
    # Loob kustutamisel tööülesande ja kontrollib selle olekut

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Kontrollib ülesannet kaugarvutites

.NOTES     Tööülesande lubamiseks või loomiseks on vaja administraatoriõigusi.
Tööülesande tee: \Microsoft\Windows\PI\Secure-Boot-Update
    Ülesanne käivitatakse taskhostw.exe iga 12 tunni järel ülemaõigustega.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parameter(Position=0)]
    [ValidteSet('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" # Märkus. See skript töötab lõpp-punktides, et lubada Secure Boot Update'i toiming.

$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
        Tõrge = $null
    }

    try {         if ($Computer -eq $env:COMPUTERNAME -või $Computer -eq "localhost" -or $Computer -eq ".") {
            # Kasutage schtasks.exe tööülesannete tuvastamiseks
            $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # Ülesannet ei leitud pole tõrge – tähendab lihtsalt, et ülesannet pole olemas
                $result. TaskExists = $false
                tagastus $result
            }
            
            # CSV-väljundi sõelumine
            $taskData = $schtasksOutput | ConvertFrom-Csv
            if ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Töötab')
                
                # Proovige andmetest
järgmist käitusaega                 if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    proovige {
                        $result. NextRunTime = [KuupäevKellaaeg]::P arse($taskData.'Järgmine käitusaeg')
                    } püüdmine { }
                }
            }
        }
        else {
            # Kaugarvuti – Invoke-Command kasutamine schtasksiga
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Väljund = $output
                }
            } - ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Ülesannet ei leitud pole tõrge – tähendab lihtsalt, et ülesannet pole olemas
                $result. TaskExists = $false
                tagastus $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 'Töötab')
            }
        }
    }
    püüdmine : {
        $result. Tõrge = $_. Erand.Sõnum
    }

    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     # Kasutab koos klassiga SBServicing ComHandlerit, töötab localSystemina
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Ülesande versioon="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <kuupäev>2012-02-07T16:39:20</Kuupäev>
    <SecurityDescriptor>O:BAG:BAD:P(A;; PV;;; BA)(A;; PV;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <allika>'$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <Autor>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <kirjeldus>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
  <subjektid>
    <principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </principal>
  </Principals>
  <sätete>
    <DisallowStartIfOnBatteries>väärad</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries>väärad</StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <StartWhenAvailable>tõene</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd>tõene</StopOnIdleEnd>
      <RestartOnIdle>väär</RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>tõene</UseUnifiedSchedulingEngine>
  </Settings>
  <päästikud>
    <BootTrigger>
      PT5M-</Delay>>viivitus <
viivitus       <kordus>
        <interval>PT12H</interval>
      </Kordus>
    </BootTrigger>
  </Triggers>
  <Actions Context="LocalSystem">
    <ComHandler>
      <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <andmete><! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</Task>
" @

    try {         if ($Computer -eq $env:COMPUTERNAME -või $Computer -eq "localhost" -or $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Salvesta XML ajutise failina ja importimiseks
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Kodeerimine 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 -Kodeerimine Unicode –Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile –Force – ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Väljund = $output }
                } – ArgumentListi $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                kui ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Väljund - join " "
                }
            }
        }
    }
    püüdmine : {
        $errorMsg = $_. Erand.Sõnum
    }

    return @{         Õnnestus = $success
        Tõrge = $errorMsg
    }
}

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

    $success = $false     $errorMsg = $null

    try {         if ($Computer -eq $env:COMPUTERNAME -või $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äljund = $output }
                } - ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                kui ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Väljund - join " "
                }
            }
        }
    }
    püüdmine : {
        $errorMsg = $_. Erand.Sõnum
    }

    return @{         Õnnestus = $success
        Tõrge = $errorMsg
    }
}

# Main execution Write-Host ""
Write-Host "========================================" – esiplaanivärvivärvi tsüaan
Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" – esiplaanivärvivärvi tsüaan

Write-Host Write-Host "Task: $TaskPath$TaskName" -ForegroundColor Gray
Write-Host

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

$results = @()

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

    $status = Get-SecureBootTaskStatus – arvuti $computer

    if ($status. Tõrge) {
        Write-Host " Tõrge: $($status. Error)" -ForegroundColor Red
    }
    elseif (mitte $status. TaskExists) {
        Write-Host " Tööülesannet pole selles süsteemis olemas" –Esiplaanivärv: punane

        # Loo taotluse korral või küsi, kui luba on määratud
        $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
           
Write-Host             Write-Host " Tööülesanne võib olla kustutatud." –Esiplaanivärvi kollane
            kui ($Quiet) {
                Write-Host " Auto-creating task (Quiet mode)" -ForegroundColor Cyan
                $shouldCreate = $true
            } else {
                $confirm = Read-Host " Kas soovite tööülesande uuesti luua?                    (Y/N)"
                if ($confirm -eq 'Y' -or $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        if ($shouldCreate) {
            Write-Host "Creating task..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask – arvuti $computer
            
            if ($createResult.Success) {
                Write-Host " Ülesanne on loodud" – esiplaanivärv: roheline
                # Kontrolli olekut
uuesti                 $status = Get-SecureBootTaskStatus – arvuti $computer
                
                if ($status. TaskExists) {
                    $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
                    Write-Host " Olek: $($status. TaskState)" - ForegroundColor $stateColor
                }
            }
            else {
                Write-Host " Loomine nurjus: $($createResult.Error)" -Esiplaanivärv: punane
            }
        }
    }
    else {
        $stateColor = if ($status. IsEnabled) { "Green" } else { "Red" }
        Write-Host " Olek: $($status. TaskState)" - ForegroundColor $stateColor
        
        if ($status. LastRunTime – ja $status. LastRunTime –ne [DateTime]::MinValue) {
            Write-Host " Viimane käitus: $($status. LastRunTime)" – esiplaanivärvi hall
        }
        if ($status. NextRunTime – ja $status. NextRunTime – ne [DateTime]::MinValue) {
            Write-Host " Järgmine käitus: $($status. NextRunTime)" – esiplaanivärvi hall
        }

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

            if ($enableResult.Success) {
                Write-Host " Task enabled successfully" -ForegroundColor Green
                # Kontrolli olekut
uuesti                 $status = Get-SecureBootTaskStatus – arvuti $computer
            }
            else {
                Write-Host " Lubamine nurjus: $($enableResult.Error)" -Esiplaanivärvi punane
            }
        }
        elseif ($Enable -and $status. IsEnabled) {
            Write-Host " Ülesanne on juba lubatud" – esiplaanivärvi roheline
värv         }
    }

    $results += $status
   
Write-Host }                  

# Summary Write-Host "========================================" – esiplaanivärvivärvi tsüaan
Write-Host " Summary" -ForegroundColor Cyan
Write-Host "========================================" – esiplaanivärvivärvi tsüaan

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists -and -not $_. IsEnabled }). Loendus
$notFound = ($results | Where-Object { -not $_. TaskExists }). Loendus
$errors = ($results | Where-Object { $_. Tõrge }). Loendus

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 "Ei leitud: $notFound" -Esiplaanivärvi kollane }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results