Esimerkki Enable-SecureBootUpdateTask.ps1-komentosarjasta

<# . SYNOPSIS
    Ottaa käyttöön suojatun käynnistyksen päivityksen ajoitetun tehtävän.

.DESCRIPTION     Tämä komentosarja varmistaa Windowsin suojatun käynnistyksen päivityksen ajoitetun tehtävän
    (\Microsoft\Windows\PI\Secure-Boot-Update) on käytössä. Jos se on poistettu käytöstä,
    se ottaa sen käyttöön. Jos tehtävä on poistettu, se voi luoda sen uudelleen.

.PARAMETER Action     Suoritettava toiminto. Kelvolliset arvot: tarkista, ota käyttöön, luo
    - tarkista: tarkista vain tehtävän tila
    - ota käyttöön: (oletus) Ota tehtävä käyttöön, jos se on poistettu käytöstä. Jos tehtävä puuttuu, kehottaa luomaan.
- luo: Luo tehtävä, jos sitä ei ole

.PARAMETER ComputerName     Valinnainen. Tietokoneiden nimien matriisi, jossa tehtävä tarkistetaan tai otetaan käyttöön.
Jos määritystä ei ole määritetty, suoritetaan paikallisessa tietokoneessa.

.PARAMETER Credential     Valinnainen. Etätietokonekäytön tunnistetiedot.

.PARAMETER Quiet     Estää kehotteet ja vastaa automaattisesti Kyllä. Hyödyllinen automaation kannalta.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Ottaa tehtävän tilan käyttöön paikallisessa tietokoneessa

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 ota käyttöön
    # Ottaa tehtävän käyttöön, jos se ei ole käytössä. Kehotteet, jos se puuttuu.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 luominen
    # Luo tehtävän, jos se on poistettu, ja tarkistaa sen tilan

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Tarkistaa etäkoneiden tehtävän

.NOTES     Tehtävän ottaminen käyttöön tai luominen edellyttää järjestelmänvalvojan oikeuksia.
Tehtäväpolku: \Microsoft\Windows\PI\Secure-Boot-Update
    Tehtävä suoritetaan taskhostw.exe 12 tunnin välein järjestelmänvalvojan oikeuksin.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parametri(Position=0)]
    [ValidateSet('check', 'enable', 'create', '')]
    [merkkijono]$Action = 'ota käyttöön',

    [Parameter()]     [merkkijono[]]$ComputerName,

    [Parameter()]     [PSCredential]$Credential,

    [Parameter()]     [Alias('Voima', 'Hiljainen')]
    [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" # Huomautus: Tämä komentosarja suoritetaan päätepisteissä suojatun käynnistyksen päivitystehtävän käyttöönottoa varten.

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

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

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

    try {         jos ($Computer -eq $env:COMPUTERNAME -tai $Computer -eq "localhost" -tai $Computer -eq ".") {
            # Käytä schtasks.exe luotettavampaan tehtäväntunnistukseen
            $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            jos ($LASTEXITCODE -ne 0) {
                # Tehtävää ei löydy ei ole virhe – tarkoittaa vain, että tehtävää ei ole olemassa
                $result. TaskExists = $false
                palauta $result
            }
            
            # Jäsentä CSV-tulos
            $taskData = $schtasksOutput | ConvertFrom-Csv
            jos ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Yritä saada seuraava suoritusaika tiedoista
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    kokeile {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Next Run Time')
                    } saalis { }
                }
            }
        }
        muu {
            # Etätietokone – Invoke-Command käyttäminen schtaskien
kanssa             $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Tulos = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Tehtävää ei löydy ei ole virhe – tarkoittaa vain, että tehtävää ei ole olemassa
                $result. TaskExists = $false
                palauta $result
            }

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

    return $result
}

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

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Käyttää ComHandleria SBServicing -luokan kanssa, toimii localsystem-muodossa
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Tehtävän versio="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Päivämäärä>2012-02-07T16:39:20</Date>
    <SecurityDescriptor>O:BAG:BAD:P(A;; FA;;; BA)(A;; FA;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <Lähde->$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <Author>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <kuvaus>$(@%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>
  <Asetukset->
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <AloitusValintojen>tosi</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd>tosi</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
  </Settings>
  <käynnistää>
    <BootTrigger>
      <viive>PT5M</Delay>
      <toisto>
        <intervalliväli>PT12H</Interval>
      </Toisto->
    </BootTrigger>
  </Triggers>
  <Toiminnot Context="LocalSystem">
    <ComHandler>
      <ClassId->{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId->
      <Data><! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</Task>
" @

    try {         jos ($Computer -eq $env:COMPUTERNAME -tai $Computer -eq "localhost" -tai $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Tallenna XML tilapäistiedostoon ja tuo
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Koodaus Unicode -Force
                
                $output = schtasks.exe /Create /TN "$TaskPath$TaskName" /XML $tempFile /F 2>&1
                
                Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                
                jos ($LASTEXITCODE -eq 0) {
                    $success = $true
                } muu {
                    $errorMsg = $output -join " "
                }
            }
        }
        muu {
            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 -Koodaus Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Tulos = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                jos ($result. ExitCode -eq 0) {
                    $success = $true
                } muu {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

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

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

    $success = $false     $errorMsg = $null

    try {         jos ($Computer -eq $env:COMPUTERNAME -tai $Computer -eq "localhost" -tai $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Enable scheduled task")) {
                $output = schtasks.exe /Change /TN "$TaskPath$TaskName" /ENABLE 2>&1
                jos ($LASTEXITCODE -eq 0) {
                    $success = $true
                } muu {
                    $errorMsg = $output -join " "
                }
            }
        }
        muu {
            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; Tulos = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                jos ($result. ExitCode -eq 0) {
                    $success = $true
                } muu {
                    $errorMsg = $result. Output -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

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

# Main execution Write-Host ""
Write-Host "========================================" -EdustaVärisyan
Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" -EtualallaColor Cyan
Write-Host ""
Write-Host "Tehtävä: $TaskPath$TaskName" -EdustaVäri harmaa
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

    jos ($status. Virhe) {
        Write-Host " Virhe: $($status. Virhe)" -EtualallaColor Punainen
    }
    elseif (ei $status. TaskExists) {
        Write-Host " Tehtävää ei ole tässä järjestelmässä" -Edustaväri Punainen

        # Luo pyydettäessä tai kysy, onko Ota käyttöön määritetty
        $shouldCreate = $Create
        jos (ei $shouldCreate - ja $Enable) {
            Write-Host ""
            Write-Host "Tehtävä on ehkä poistettu". -Edustaväri Keltainen
            jos ($Quiet) {
                Write-Host " Automaattinen luontitehtävä (hiljainen tila)" -Edustavärisyan
                $shouldCreate = $true
            } muu {
                $confirm = Read-Host " Haluatko luoda tehtävän uudelleen?                    (Y/N)"
                jos ($confirm -eq 'Y' -tai $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        jos ($shouldCreate) {
            Write-Host " Tehtävän luominen..." -EdustaVäri Keltainen
            $createResult = New-SecureBootTask -Computer $computer
            
            if ($createResult.Success) {
                Write-Host " Tehtävä luotu onnistuneesti" -EdustaVäri vihreä
                # Tarkista tila
uudelleen                 $status = Get-SecureBootTaskStatus -Computer $computer
                
                jos ($status. TaskExists) {
                    $stateColor = jos ($status. IsEnabled) { "Green" } muu { "Punainen" }
                    Write-Host " Osavaltio: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            muu {
                Write-Host " Failed to create: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    muu {
        $stateColor = jos ($status. IsEnabled) { "Green" } muu { "Punainen" }
        Write-Host " Osavaltio: $($status. TaskState)" -ForegroundColor $stateColor
        
        jos ($status. LastRunTime ja $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Viimeinen suoritus: $($status. LastRunTime)" -ForegroundColor Harmaa
        }
        jos ($status. NextRunTime ja $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Seuraava suoritus: $($status. NextRunTime)" -EtualallaColor Harmaa
        }

        # Enable if requested and currently disabled         jos ($Enable -ja -not $status. OnEnabled) {
            Write-Host " Tehtävän ottaminen käyttöön..." -EtualallaVäri keltainen
            $enableResult = Enable-SecureBootTask -Computer $computer

            if ($enableResult.Success) {
                Write-Host " Tehtävä otettu onnistuneesti käyttöön" -EdustaVäri vihreä
                # Tarkista tila
uudelleen                 $status = Get-SecureBootTaskStatus -Computer $computer
            }
            muu {
                Write-Host " Failed to enable: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable - ja $status. OnEnabled) {
            Write-Host " Tehtävä on jo käytössä" -EdustaVäri vihreä
        }
    }

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

# Summary Write-Host "========================================" -Edustavärisyan
Write-Host " Yhteenveto" -EdustaVärisyan
Write-Host "========================================" -EtualallaVärisyan

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists -and -not $_. IsEnabled }). Laskea
$notFound = ($results | Where-Object { -not $_. TaskExists }). Laskea
$errors = ($results | Where-Object { $_. Virhe }). Laskea

Write-Host "Total Checked: $($results.Count)" Write-Host "Käytössä: $enabled" -EdustaVäri vihreä
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