Script de Enable-SecureBootUpdateTask.ps1 de exemplo

<# . SYNOPSIS
    Ativa a tarefa agendada atualização de arranque seguro.

.DESCRIPTION     Este script garante a tarefa
agendada da Atualização de Arranque Seguro do Windows     O (\Microsoft\Windows\PI\Secure-Boot-Update) está ativado. Se estiver desativado,
    permite-lhe. Se a tarefa tiver sido eliminada, pode recriá-la.

.PARAMETER Action     A ação a executar. Valores válidos: verificar, ativar, criar
    - verificar: Verificar apenas o estado
da tarefa     - ativar: (predefinição) Ative a tarefa se estiver desativada. Se a tarefa estiver em falta, é pedido para criar.
- criar: criar a tarefa se não existir

.PARAMETER ComputerName     Opcional. Matriz de nomes de computador para verificar/ativar a tarefa.
Se não for especificado, é executado no computador local.

.PARAMETER Credential     Opcional. Credenciais para acesso remoto ao computador.

.PARAMETER Quiet     Suprime pedidos e responde automaticamente sim. Útil para automatização.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Ativa o estado da tarefa no computador local

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 ativar
    # Ativa a tarefa se estiver desativada. Pedidos criar se estiver em falta.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 criar
    # Cria a tarefa se tiver sido eliminada e, em seguida, verifica o respetivo estado

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 check -ComputerName "PC1", "PC2"
    # Verifica a tarefa em computadores remotos

.NOTES     Requer privilégios de administrador para ativar ou criar a tarefa.
Caminho da Tarefa: \Microsoft\Windows\PI\Secure-Boot-Update
    A tarefa é executada taskhostw.exe a cada 12 horas com privilégios elevados.
#>

[CmdletBinding(SupportsShouldProcess)] parâmetro(
    [Parameter(Position=0)]
    [ValidateSet('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" Nota: este script é executado em pontos finais para ativar a tarefa Atualização de Arranque Seguro.

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

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

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

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            # Utilize schtasks.exe para deteção
de tarefas mais fiável             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            if ($LASTEXITCODE -ne 0) {
                # A tarefa não encontrada não é um erro – significa apenas que a tarefa não existe
                $result. TaskExists = $false
                devolver $result
            }
            
            # Analisar a saída
CSV             $taskData = $schtasksOutput | ConverterFrom-Csv
            se ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
                
                # Tente obter a hora de execução seguinte a partir dos dados
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    experimente {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Next Run Time')
                    } captura { }
                }
            }
        }
        else {
            # Computador remoto - utilize Invoke-Command com schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                parâmetro($fullTaskName)
                $output = schtasks.exe /Query /TN $fullTaskName /FO CSV 2>&1
                @{
                    ExitCode = $LASTEXITCODE
                    Saída = $output
                }
            } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop

            if ($remoteResult.ExitCode -ne 0) {                 # A tarefa não encontrada não é um erro – significa apenas que a tarefa não existe
                $result. TaskExists = $false
                devolver $result
            }

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

    return $result
}

function New-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    parâmetro(
        [string]$Computer = $env:COMPUTERNAME
    )

    $success = $false     $errorMsg = $null

    # Task definition - matches the original Windows Secure Boot Update task     # Utiliza o ComHandler com a classe SBServicing, é executado como LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Versão da tarefa="1,6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Data>2012-02-07T16:39:20</Data>
    <SecurityDescriptor>O:BAG:BAD:P(A;; FA;;; BA)(A;; FA;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <>de Origem '$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <Author>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <Descrição>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <URI>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
 >
<Principais     <Principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </Principal>
  </Principais>
 >de Definições de <
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries>falso</StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit>pt1H</ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <IniciarQuando Disponível>verdadeiro</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd>verdadeiro</StopOnIdleEnd>
      <RestartOnIdle>falso</RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>verdadeiro</UseUnifiedSchedulingEngine>
  </Definições>
 >de Acionadores <
    <bootTrigger>
      <Atraso><PT5M /Atraso>
     >repetição de <
        Intervalo de <><PT12H /Intervalo>
      </Repetição>
    </BootTrigger>
  </Acionadores>
  <Actions Context="LocalSystem">
    <comHandler>
      <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <data><! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</>de Tarefas
" @

    try {         if ($Computer -eq $env:COMPUTERNAME -or $Computer -eq "localhost" -or $Computer -eq ".") {
            if ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Create scheduled task")) {
                # Guarde XML no ficheiro temporário e importe
                $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
                
                if ($LASTEXITCODE -eq 0) {
                    $success = $true
                } senão {
                    $errorMsg = $output -join " "
                }
            }
        }
        else {
            if ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Criar tarefa agendada")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    parâmetro($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; Saída = $output }
                } -ArgumentList $TaskPath, $TaskName, $taskXml -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } senão {
                    $errorMsg = $result. Saída -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Êxito = $success
        Erro = $errorMsg
    }
}

function Enable-SecureBootTask {     [CmdletBinding(SupportsShouldProcess)]
    parâmetro(
        [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", "Ativar tarefa agendada")) {
                $output = schtasks.exe /Change /TN "$TaskPath$TaskName" /ENABLE 2>&1
                if ($LASTEXITCODE -eq 0) {
                    $success = $true
                } senão {
                    $errorMsg = $output -join " "
                }
            }
        }
        else {
            if ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Ativar tarefa agendada")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    parâmetro($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Saída = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                if ($result. ExitCode -eq 0) {
                    $success = $true
                } senão {
                    $errorMsg = $result. Saída -join " "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

    return @{         Êxito = $success
        Erro = $errorMsg
    }
}

# Main execution Write-Host ""
Write-Host "========================================" -ForegroundColor Cyan
Write-Host " Secure Boot Update Task Enabler" -ForegroundColor Cyan
Write-Host "========================================" -ForegroundColor Cyan
Write-Host ""
Write-Host "Task: $TaskPath$TaskName" -ForegroundColor Gray
Write-Host ""

# Determine target computers $targets = se ($ComputerName) { $ComputerName } senão { @($env:COMPUTERNAME) }

$results = @()

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

    $status = Get-SecureBootTaskStatus -$computer

do computador     if ($status. Erro) {
        Write-Host " Erro: $($status. Erro)" -ForegroundColor Vermelho
    }
    elseif (-não $status. TaskExists) {
        Write-Host " A tarefa não existe neste sistema" -ForegroundColor Vermelho

        # Criar, se solicitado, ou perguntar se a opção Ativar foi especificada
        $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host " A tarefa pode ter sido eliminada." -Primeiro PlanoColor Amarelo
            se ($Quiet) {
                Write-Host " Tarefa de criação automática (modo silencioso)" -ForegroundColor Cyan
                $shouldCreate = $true
            } senão {
                $confirm = Read-Host " Pretende recriar a tarefa?                    (Y/N)"
                if ($confirm -eq 'Y' -or $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }
        
        se ($shouldCreate) {
            Write-Host " Creating task..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask -$computer
            
do computador             if ($createResult.Success) {
                Write-Host " Tarefa criada com êxito" - Primeiro PlanoColor Verde
                # Verificar novamente o estado
                $status = Get-SecureBootTaskStatus -Computer $computer
                
                if ($status. TaskExists) {
                    $stateColor = se ($status. IsEnabled) { "Verde" } senão { "Vermelho" }
                    Write-Host " Estado: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host " Falha ao criar: $($createResult.Error)" -ForegroundColor Vermelho
            }
        }
    }
    else {
        $stateColor = se ($status. IsEnabled) { "Verde" } senão { "Vermelho" }
        Write-Host " Estado: $($status. TaskState)" -ForegroundColor $stateColor
        
        if ($status. LastRunTime - e $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Última Execução: $($status. LastRunTime)" -ForegroundColor Gray
        }
        if ($status. NextRunTime - e $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Próxima Execução: $($status. NextRunTime)" -ForegroundColor Gray
        }

        # Enable if requested and currently disabled         if ($Enable -and -not $status. IsEnabled) {
            Write-Host " Ativar tarefa..." -Primeiro PlanoColor Amarelo
            $enableResult = Enable-SecureBootTask -$computer de computador

            if ($enableResult.Success) {
                Write-Host " Tarefa ativada com êxito" - Primeiro PlanoColor Verde
                # Verificar novamente o estado
                $status = Get-SecureBootTaskStatus -$computer de
computador             }
            else {
                Write-Host " Falha ao ativar: $($enableResult.Error)" -ForegroundColor Vermelho
            }
        }
        elseif ($Enable - e $status. IsEnabled) {
            Write-Host " A tarefa já está ativada" -ForegroundColor Verde
        }
    }

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

# Summary Write-Host "========================================" -ForegroundColor Cyan
Write-Host " Resumo" -ForegroundColor Cyan
Write-Host "========================================" -ForegroundColor Cyan

$enabled = ($results | Where-Object { $_.IsEnabled }).Count $disabled = ($results | Where-Object { $_. TaskExists - e - não $_. IsEnabled }). Contagem
$notFound = ($results | Where-Object { -not $_. TaskExists }). Contagem
$errors = ($results | Where-Object { $_. Erro }). Contagem

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