Sample Enable-SecureBootUpdateTask.ps1 script

<# . ANOTACIJA
    Įgalina suplanuotą saugiosios įkrovos naujinimo užduotį.

.DESCRIPTION     Šis scenarijus užtikrina suplanuotą "Windows" saugiosios įkrovos naujinimo užduotį
    (\Microsoft\Windows\PI\Secure-Boot-Update) įjungtas. Jei išjungta,
    ji įgalina. Jei užduotis buvo panaikinta, ji gali ją sukurti iš naujo.

.PARAMETER Action     Veiksmas, kurį reikia atlikti. Tinkamos reikšmės: tikrinti, įgalinti, kurti
    - patikrinimas: patikrinkite tik užduoties būseną
    - enable: (numatytasis parametras) Įgalinti užduotį, jei išjungta. Jei užduoties nėra, ragina sukurti.
- kurti: sukurkite užduotį, jei jos nėra

.PARAMETER ComputerName     Pasirinktinai. Kompiuterio vardų masyvas, kurį reikia patikrinti / įgalinti užduotį.
Jei nenurodyta, paleidžiama vietiniame kompiuteryje.

.PARAMETER Credential     Pasirinktinai. Kredencialai, skirti prieigai prie nuotolinio kompiuterio.

.PARAMETER Quiet     Nerodo raginimų ir automatiškai atsako Taip. Naudinga automatizavimui.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Įgalina užduoties būseną vietiniame kompiuteryje

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 įgalinti
    # Įgalina užduotį, jei išjungta. Raginimai sukurti, jei jos nėra.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 kūrimas
    # Sukuria užduotį, jei ji buvo panaikinta, tada patikrina jos būseną

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Patikrina užduotį nuotoliniuose įrenginiuose

.NOTES     Norint įgalinti arba kurti užduotį, reikalingos administratoriaus teisės.
Užduoties kelias: \Microsoft\Windows\PI\Secure-Boot-Update
    Užduotis vykdoma taskhostw.exe kas 12 valandų didesnėmis teisėmis.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parameter(Position=0)]
    [ValidateSet('check', 'enable', 'create', '')]
    [eilutė]$Action = "enable",

    [Parameter()]     [eilutė[]$ComputerName,

    [Parameter()]     [PSCredential]$Credential,

    [Parameter()]     [Alias('Force', 'Silent')]
    [jungiklis]$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" # Pastaba: šis scenarijus veikia pabaigos taškais, kad įgalintų saugiosios įkrovos naujinimo užduotį.

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

function Get-SecureBootTaskStatus {     [CmdletBinding()]
    param(
        [eilutė]$Computer = $env:COMPUTERNAME
    )

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

    try {         jei ($Computer -eq $env:COMPUTERNAME arba $Computer -eq "localhost" -arba $Computer -eq ".") {
            # Norėdami patikimiau aptikti
užduotis, naudokite schtasks.exe             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            jei ($LASTEXITCODE -ne 0) {
                # Užduotis nerasta – tai ne klaida – tiesiog reiškia, kad užduoties nėra
                $result. TaskExists = $false
                grąžinimo $result
            }
            
            # Sintaksės analizės CSV išvestis
            $taskData = $schtasksOutput | ConvertFrom-Csv
            jei ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Pabandykite gauti kitą vykdymo laiką iš duomenų
                jei ($taskData."Kito vykdymo laikas" – ir $taskData."Kito vykdymo laikas" - ne "N/A") {
                    išbandykite {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Kito vykdymo laikas')
                    } sugauti { }
                }
            }
        }
        kita {
            # Nuotolinis kompiuteris – naudokite Invoke-Command su schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Išvestis = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Užduotis nerasta – tai ne klaida – tiesiog reiškia, kad užduoties nėra
                $result. TaskExists = $false
                grąžinimo $result
            }

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

    return $result
}

function New-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [eilutė]$Computer = $env:COMPUTERNAME
    )

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Naudoja ComHandler su SBServicing klase, veikia kaip LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<užduoties versija="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <data>2012-02-07T16:39:20</ datos>
    <SecurityDescriptor>O:BAG:BAD:P(A;; IT;;; BA)(A;; IT;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <šaltinio>"$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <autorius>$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <aprašas>$(@%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>
    </Pagrindinis>
  </Principals>
  <parametrų>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries>klaidingas</StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <PradžiaKas yra>true</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
  </ parametrų>
  <paleidiklių>
    <BootTrigger>
      <– delsos>PT5M</ delsos>
      <pasikartojimo>
        <intervalas>PT12H</ intervalo>
      </ pasikartojimo>
    </BootTrigger>
  </ paleidiklių>
  <Actions Context="LocalSystem">
    <apdorojimo programos>
      <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <duomenų><! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</ užduočių>
" @

    try {         jei ($Computer -eq $env:COMPUTERNAME arba $Computer -eq "localhost" -arba $Computer -eq ".") {
            jei ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Įrašyti XML į laikinąjį failą ir importuoti
                $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
                
                jei ($LASTEXITCODE -eq 0) {
                    $success = $true
                } dar {
                    $errorMsg = $output -join " "
                }
            }
        }
        kita {
            jei ($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 -Encoding Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile –Force - ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Išvestis = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                jei ($result. ExitCode -eq 0) {
                    $success = $true
                } dar {
                    $errorMsg = $result. Išvestis – sujungimas "
                }
            }
        }
    }
    sugauti {
        $errorMsg = $_. Exception.Message
    }

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

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

    $success = $false     $errorMsg = $null

    try {         jei ($Computer -eq $env:COMPUTERNAME arba $Computer -eq "localhost" -arba $Computer -eq ".") {
            jei ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Enable scheduled task")) {
                $output = schtasks.exe /Change /TN "$TaskPath$TaskName" /ENABLE 2>&1
                jei ($LASTEXITCODE -eq 0) {
                    $success = $true
                } dar {
                    $errorMsg = $output -join " "
                }
            }
        }
        kita {
            jei ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Enable scheduled task")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Keisti /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Išvestis = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                jei ($result. ExitCode -eq 0) {
                    $success = $true
                } dar {
                    $errorMsg = $result. Išvestis – sujungimas "
                }
            }
        }
    }
    sugauti {
        $errorMsg = $_. Exception.Message
    }

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

# Main execution
Write-Host Write-Host "========================================" – priekinio planopalva žydra
Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" – priekinio planopalva žydra

Write-Host Write-Host "Užduotis: $TaskPath$TaskName" - Priekinio planopalva pilka
Write-Host

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

$results = @()

foreach ($computer in $targets) {     Write-Host "Tikrinimas: $computer" – geltona

priekinio plano spalva     $status = Get-SecureBootTaskStatus - Kompiuterio $computer

    jei ($status. Klaida) {
        Write-Host " Klaida: $($status. Klaida)" -Priekinio planopalva raudona
    }
    elseif (-not $status. TaskExists) {
        Write-Host " Užduoties šioje sistemoje nėra" -Priekinio planopalva raudona

        # Kurti, jei prašoma, arba raginimas, jei buvo nurodyta
Enable         $shouldCreate = $Create
        jei (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host " Užduotis gali būti panaikinta." -Priekinio planopalva Geltona
            jei ($Quiet) {
                Write-Host " Auto-creating task (Quiet mode)" -ForegroundColor Cyan
                $shouldCreate = $true
            } dar {
                $confirm = Read-Host " Ar norite iš naujo sukurti užduotį?                    (Y/N)"
                jei ($confirm -eq 'Y' -arba $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        jei ($shouldCreate) {
            Write-Host " Kuriama užduotis..." - Geltona
priekinio plano spalva             $createResult = New-SecureBootTask - Kompiuterio $computer
            
            jei ($createResult.Success) {
                Write-Host " Užduotis sukurta sėkmingai" - Priekinio planopalva Žalia
                # Dar kartą patikrinkite būseną
                $status = Get-SecureBootTaskStatus - Kompiuterio $computer
                
                jei ($status. TaskExists) {
                    $stateColor = if ($status. IsEnabled) { "Žalia" } dar { "Raudona" }
                    Write-Host " Valstija: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            kita {
                Write-Host " Nepavyko sukurti: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    kita {
        $stateColor = if ($status. IsEnabled) { "Žalia" } dar { "Raudona" }
        Write-Host " Būsena: $($status. TaskState)" -ForegroundColor $stateColor
        
        jei ($status. LastRunTime – ir $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Paskutinį kartą vykdyta: $($status. LastRunTime)" -Priekinio planopalva pilka
        }
        jei ($status. NextRunTime – ir $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Kitas paleidimas: $($status. NextRunTime)" -Priekinio planopalva pilka
        }

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

            jei ($enableResult.Success) {
                Write-Host " Task enabled successfully" -ForegroundColor Green
                # Dar kartą patikrinkite būseną
                $status = Get-SecureBootTaskStatus -Computer $computer
            }
            kita {
                Write-Host " Nepavyko įgalinti: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable ir $status. IsEnabled) {
            Write-Host " Užduotis jau įgalinta" - Priekinio planopalva Žalia
        }
    }

    $results += $status
   
Write-Host }                  

# Summary Write-Host "========================================" – priekinio planopalva žydra
Write-Host " Summary" -ForegroundColor Cyan
Write-Host "========================================" – priekinio planopalva žydra

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists – ir ne $_. IsEnabled }). Skaičius
$notFound = ($results | Where-Object { -not $_. TaskExists }). Skaičius
$errors = ($results | Where-Object { $_. Klaida }). Skaičius

Write-Host "Total Checked: $($results.Count)" Write-Host "Enabled: $enabled" -ForegroundColor Green
jei ($disabled -gt 0) { Write-Host "Išjungta: $disabled" -Priekinio plano spalvos raudona }
jei ($notFound -gt 0) { Write-Host "Nerasta: $notFound" -Priekinio planopalva Geltona }
jei ($errors -gt 0) { Write-Host "Klaidos: $errors" -Priekinio planopalva Raudona }

# Return results for pipeline $results