Exemplu de script Enable-SecureBootUpdateTask.ps1

<# . SINOPSIS
    Activează activitatea programată Secure Boot Update.

.DESCRIPTION     Acest script asigură activitatea
programată Windows Secure Boot Update     (\Microsoft\Windows\PI\Secure-Boot-Update) este activat. Dacă este dezactivat,
    acesta o activează. Dacă activitatea a fost ștearsă, aceasta o poate crea din nou.

.PARAMETER Action     Acțiunea de efectuat. Valori valide: verificare, activare, creare
    - verificare: Verificați doar starea
activității     - activare: (implicit) Activați activitatea dacă este dezactivată. Dacă activitatea lipsește, vă solicită să o creați.
- creare: Creați activitatea dacă nu există

.PARAMETER ComputerName     Opţional. Matrice de nume de computere pe care să verificați/activați activitatea.
Dacă nu se specifică, rulează pe computerul local.

.PARAMETER Credential     Opţional. Acreditări pentru acces la computer la distanță.

.PARAMETER Quiet     Elimină solicitările și răspunde automat Da. Util pentru automatizare.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Activează starea activității pe computerul local

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 activat
    # Activează activitatea dacă este dezactivată. Solicitări de creat dacă lipsește.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 crea
    # Creează activitatea dacă a fost ștearsă, apoi îi verifică starea

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 bifați -NumeComputer "PC1", "PC2"
    # Verifică activitatea pe mașini la distanță

.NOTES     Necesită privilegii de administrator pentru a activa sau a crea activitatea.
Cale activitate: \Microsoft\Windows\PI\Secure-Boot-Update
    Activitatea rulează taskhostw.exe la fiecare 12 ore, cu privilegii sporite.
#>

[CmdletBinding(SupportsShouldProcess)] param(
    [Parametru(Poziție=0)]
    [ValidateSet('check', 'enable', 'create', '')]
    [string]$Action = 'enable',

    [Parameter()]     [șir[]]$ComputerName,

    [Parameter()]     [PSCredential]$Credential,

    [Parameter()]     [Alias('Force', 'Silent')]
    [argument]$Quiet
)

# Convert Action to switches for backward compatibility $Enable = $Action -eq "enable"
$Create = $Action -eq "creare"

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples" # Notă: Acest script rulează pe punctele finale pentru a activa activitatea Secure Boot Update.

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

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

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

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            # Utilizați schtasks.exe pentru o detectare
mai fiabilă a activităților             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            dacă ($LASTEXITCODE -ne 0) {
                # Activitatea negăsită nu este o eroare - înseamnă doar că activitatea nu există
                $result. TaskExists = $false
                $result
de returnare             }
            
            # Analizați ieșirea
CSV             $taskData = $schtasksOutput | ConvertFrom-Csv
            dacă ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -sau $taskData.Status -eq 'Running')
                
                # Încercați să obțineți timpul de rulare următor din date
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    încercați {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Ora următoarei rulări')
                    } captură { }
                }
            }
        }
        altfel, {
            # Computer la distanță - utilizarea Invoke-Command cu schtasks
            $remoteResult = Invoke-Command -NumeComputer $Computer -ScriptBlock {
                param($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Ieșire = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # Activitatea negăsită nu este o eroare - înseamnă doar că activitatea nu există
                $result. TaskExists = $false
                $result
de returnare             }

            $taskData = $remoteResult.Output | ConvertFrom-Csv             dacă ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -sau $taskData.Status -eq 'Running')
            }
        }
    }
    captură {
        $result. Eroare = $_. Excepție.mesaj
    }

    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     # Utilizează ComHandler cu clasa SBServicing, rulează ca LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Versiune activitate="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
 >InformațiiÎnregistrare <
    <data>2012-02-07T16:39:20</Data>
    <SecurityDescriptor>O:BAG:BAD:P(A;; FA;;; BA)(A;; FA;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <>sursă '$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <autor>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    descrierea <>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    uri <>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
 ></RegistrationInfo
 >
directori <     <id principal="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </principal>
  </Principals>
 >
setări <     <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries><fals /StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>PT1H</ExecutionTimeLimit>
    ><8>MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <StartAtunci când>adevărat</StartAtunci când>
   >IdleSettings <
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle><fals /RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
 ></Setări
 >Triggere
<    >BootTrigger <
      <întârziere>PT5M</întârziere>
      <>
repetiție         Interval <>PT12H</Interval>
     ></Repetiție
   ></BootTrigger
 ></Triggere
  <Actions Context="LocalSystem">
    <>
ComHandler       <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
     >< de date <! [CDATA[SBServicing]]></Data>
    </ComHandler>
 ></Acțiuni
</>de activitate
" @

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Salvare XML în fișier temporar și import
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Codificare Unicode -Force
                
                $output = schtasks.exe /Create /TN "$TaskPath$TaskName" /XML $tempFile /F 2>&1
                
                Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                
                dacă ($LASTEXITCODE -eq 0) {
                    $success = $true
                } altfel, {
                    $errorMsg = $output -join " "
                }
            }
        }
        altfel, {
            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 -Codificare Unicode -Force
                    $output = schtasks.exe /Create /TN "$taskPath$taskName" /XML $tempFile /F 2>&1
                    Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                    @{ ExitCode = $LASTEXITCODE; Ieșire = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                dacă ($result. ExitCode -eq 0) {
                    $success = $true
                } altfel, {
                    $errorMsg = $result. Ieșire -unire " " "
                }
            }
        }
    }
    captură {
        $errorMsg = $_. Excepție.mesaj
    }

    return @{         Succes = $success
        Eroare = $errorMsg
    }
}

function Enable-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    param(
        [string]$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
                dacă ($LASTEXITCODE -eq 0) {
                    $success = $true
                } altfel, {
                    $errorMsg = $output -join " "
                }
            }
        }
        altfel, {
            if ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Enable scheduled task")) {
                $result = Invoke-Command -NumeComputer $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Ieșire = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                dacă ($result. ExitCode -eq 0) {
                    $success = $true
                } altfel, {
                    $errorMsg = $result. Ieșire -unire " " "
                }
            }
        }
    }
    captură {
        $errorMsg = $_. Excepție.mesaj
    }

    return @{         Succes = $success
        Eroare = $errorMsg
    }
}

# Main execution Write-Host ""
Write-Host "========================================" -Prim-planColor Cyan
Write-Host "Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" -Prim-planColor Cyan
Write-Host ""
Write-Host "Activitate: $TaskPath$NumeA activități" -Culoare prim plan gri
Write-Host ""

# Determine target computers $targets = dacă ($ComputerName) { $ComputerName } altceva { @($env:COMPUTERNAME) }

$results = @()

foreach ($computer in $targets) {     Write-Host "Verificare: $computer" -Culoare prim plan galben

    $status = Get-SecureBootTaskStatus - $computer

computerului     dacă ($status. Eroare) {
        Write-Host " Eroare: $($status. Eroare)" -Prim-planColor roșu
    }
    elseif (-nu $status. TaskExists) {
        Write-Host " Activitatea nu există în acest sistem" -Prim planColor Roșu

        # Creați dacă este solicitat sau solicitați dacă s-a specificat
Activare         $shouldCreate = $Create
        dacă (-nu $shouldCreate -și $Enable) {
            Write-Host ""
            Write-Host " Este posibil ca activitatea să fi fost ștearsă". -Culoare prim plan galbenă
            dacă ($Quiet) {
                Write-Host " Activitate de creare automată (mod silențios)" -Prim-planColor Cyan
                $shouldCreate = $true
            } altfel, {
                $confirm = Read-Host " Creați din nou activitatea?                    (Y/N)"
                dacă ($confirm -eq 'Y' sau $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        dacă ($shouldCreate) {
            Write-Host "Se creează activitatea..." -Prim-planColor galben
            $createResult = New-SecureBootTask - $computer
            
computerului             dacă ($createResult.Success) {
                Write-Host " Activitate creată cu succes" -Prim-planColor verde
                # Verificați din nou starea
                $status = Get-SecureBootTaskStatus -Computer $computer
                
                dacă ($status. TaskExists) {
                    $stateColor = dacă ($status. IsEnabled) { "Verde" } altceva { "Roșu" }
                    Write-Host " Stat: $($status. TaskState)" -Prim planColor $stateColor
                }
            }
            altfel, {
                Write-Host " Nu s-a reușit crearea: $($createResult.Error)" -Prim-planColor roșu
            }
        }
    }
    altfel, {
        $stateColor = dacă ($status. IsEnabled) { "Verde" } altceva { "Roșu" }
        Write-Host " Stat: $($status. TaskState)" -Prim planColor $stateColor
        
        dacă ($status. LastRunTime -și $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Ultima rulare: $($status. LastRunTime)" -Prim-planColor gri
        }
        dacă ($status. NextRunTime -și $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Următoarea rulare: $($status. NextRunTime)" -Prim-planColor gri
        }

        # Enable if requested and currently disabled         dacă ($Enable -și -nu $status. IsEnabled) {
            Write-Host "Se activează activitatea..." -Prim-planColor galben
            $enableResult = Enable-SecureBootTask - $computer

computerului             dacă ($enableResult.Success) {
                Write-Host "Activitatea s-a activat cu succes" -Prim-planColor Verde
                # Verificați din nou starea
                $status = Get-SecureBootTaskStatus -Computer $computer
            }
            altfel, {
                Write-Host " Nu s-a reușit activarea: $($enableResult.Error)" -Prim-planColor roșu
            }
        }
        elseif ($Enable și $status. IsEnabled) {
            Write-Host " Activitatea este deja activată" -Prim-planColor Verde
        }
    }

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

# Summary Write-Host "========================================" -Prim-planColor Cyan
Write-Host "Rezumat" -Prim planColor Cyan
Write-Host "========================================" -Prim-planColor Cyan

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

Write-Host "Total Checked: $($results.Count)" Write-Host "Activat: $enabled" - Verde
prim plan if ($disabled -gt 0) { Write-Host "Disabled: $disabled" -ForegroundColor Red }
dacă ($notFound -gt 0) { Write-Host "Negăsit: $notFound" -Prim planColor Galben }
if ($errors -gt 0) { Write-Host "Errors: $errors" -ForegroundColor Red }

# Return results for pipeline $results