Exemplo Enable-SecureBootUpdateTask.ps1 script

<# . SINOPSE
    Habilita a tarefa agendada Atualização de Inicialização Segura.

.DESCRIPTION     Este script garante a tarefa
agendada do Windows Secure Boot Update     (\Microsoft\Windows\PI\Secure-Boot-Update) está habilitado. Se estiver desabilitado,
    ele o habilita. Se a tarefa foi excluída, ela poderá recriá-la.

.PARAMETER Action     A ação a ser executada. Valores válidos: marcar, habilitar, criar
    - marcar: somente marcar a tarefa status
    – habilitar: (padrão) Habilitar a tarefa se estiver desabilitada. Se a tarefa estiver ausente, solicitará a criação.
– criar: criar a tarefa se ela não existir

.PARAMETER ComputerName     Opcional. Matriz de nomes de computador para marcar/habilitar a tarefa.
Se não for especificado, será executado no computador local.

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

.PARAMETER Quiet     Suprime prompts e responde automaticamente Sim. Útil para automação.

.EXAMPLE     .\Enable-SecureBootTask.ps1
    # Habilita a tarefa status no computador local

.EXAMPLE     habilitar
.\Check-SecureBootScheduledTask.ps1     # Habilita a tarefa se estiver desabilitada. Prompts criar se estiver ausente.

.EXAMPLE     .\Check-SecureBootScheduledTask.ps1 criar
    # Cria a tarefa se ela foi excluída e verifica seu status

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

.NOTES     Requer privilégios de administrador para habilitar 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)] param(
    [Parameter(Position=0)]
    [ValidateSet('marcar', '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" # Observação: este script é executado em pontos de extremidade para habilitar a tarefa Atualização de Inicialização Segura.

$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
        Erro = $null
    }

    try {         se ($Computer -eq $env:COMPUTERNAME -ou $Computer -eq "localhost" -ou $Computer -eq ".") {
            # Use schtasks.exe para detecção
de tarefas mais confiável             $schtasksOutput = schtasks.exe /Query /TN "$TaskPath$TaskName" /FO CSV 2>&1
            
            se ($LASTEXITCODE -ne 0) {
                # A tarefa não encontrada não é um erro - apenas significa que a tarefa não existe
                $result. TaskExists = $false
                retornar $result
            }
            
            # Analisar saída CSV
            $taskData = $schtasksOutput | ConvertFrom-Csv
            se ($taskData) {
                $result. TaskExists = $true
                $result. TaskState = $taskData.Status
                $result. IsEnabled = ($taskData.Status -eq 'Ready' -ou $taskData.Status -eq 'Running')
                
                # Tente obter o próximo tempo de execução dos dados
                if ($taskData.'Next Run Time' -and $taskData.'Next Run Time' -ne 'N/A') {
                    try {
                        $result. NextRunTime = [DateTime]::P arse($taskData.'Next Run Time')
                    } pegar { }
                }
            }
        }
        else {
            # Computador remoto – use Invoke-Command com schtasks
            $remoteResult = Invoke-Command -ComputerName $Computer -ScriptBlock {
                param($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 - apenas significa que a tarefa não existe
                $result. TaskExists = $false
                retornar $result
            }

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

    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     # Usa a classe ComHandler com SBServicing, é executada como LocalSystem
    $taskXml = @"
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Data>2012-02-07T16:39:20</Date>
    <SecurityDescriptor>O:BAG:BAD:P(A;; FA;;; BA)(A;; FA;;; SY)(A;; FRFX;;; LS)</SecurityDescriptor>
    <Origem>'$(@%SystemRoot%\system32\TpmTasks.dll,-601)</Source>
    <autor>'$(@%SystemRoot%\system32\TpmTasks.dll,-600)</Author>
    <Description>'$(@%SystemRoot%\system32\TpmTasks.dll,-604)</Description>
    <>\Microsoft\Windows\PI\Secure-Boot-Update</URI>
  </RegistrationInfo>
 >de entidades de <
    <Principal id="LocalSystem">
      <UserId>S-1-5-18</UserId>
    </Principal>
  </Principals>
  <Configurações>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    ><0 StopIfGoingOnBatteries></StopIfGoingOnBatteries>
    ><4 ExecutionTimeLimit><PT1H /ExecutionTimeLimit>
    ><8 MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <StartWhenAvailable>true</StartWhenAvailable>
    <IdleSettings>
      <StopOnIdleEnd></StopOnIdleEnd>
      <RestartOnIdle></RestartOnIdle>
    </IdleSettings>
    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
  </Configurações>
  <dispara>
   >bootTrigger <
      <atraso><pt5M />
de atraso       <>
de repetição         <intervalo><pt12H /interval>
      </repetição>
    </BootTrigger>
  </Dispara>
  <Actions Context="LocalSystem">
    <>
comHandler       <ClassId>{5014B7C8-934E-4262-9816-887FA745A6C4}</ClassId>
      <Data><! [CDATA[SBServicing]]></Data>
    </ComHandler>
  </Actions>
</Task>
" @

    try {         se ($Computer -eq $env:COMPUTERNAME -ou $Computer -eq "localhost" -ou $Computer -eq ".") {
            se ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Criar tarefa agendada")) {
                # Salvar XML para o arquivo temporário e importar
                $tempFile = [System.IO.Path]::GetTempFileName()
                $taskXml | Out-File -FilePath $tempFile -Codificando Unicode -Force
                
                $output = schtasks.exe /Create /TN "$TaskPath$TaskName" /XML $tempFile /F 2>&1
                
                Remove-Item $tempFile -Force -ErrorAction SilentlyContinue
                
                se ($LASTEXITCODE -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $output -join "
                }
            }
        }
        else {
            se ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Criar tarefa agendada")) {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($taskPath, $taskName, $xml)
                    $tempFile = [System.IO.Path]::GetTempFileName()
                    $xml | Out-File -FilePath $tempFile -Codificando 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
                
                se ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Saída -join "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

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

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

    $success = $false     $errorMsg = $null

    try {         se ($Computer -eq $env:COMPUTERNAME -ou $Computer -eq "localhost" -ou $Computer -eq ".") {
            se ($PSCmdlet.ShouldProcess("$TaskPath$TaskName", "Habilitar tarefa agendada")) {
                $output = schtasks.exe /Change /TN "$TaskPath$TaskName" /ENABLE 2>&1
                se ($LASTEXITCODE -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $output -join "
                }
            }
        }
        else {
            se ($PSCmdlet.ShouldProcess("$Computer\$TaskPath$TaskName", "Habilitar tarefa agendada")) { {
                $result = Invoke-Command -ComputerName $Computer -ScriptBlock {
                    param($fullTaskName)
                    $output = schtasks.exe /Change /TN $fullTaskName /ENABLE 2>&1
                    @{ ExitCode = $LASTEXITCODE; Saída = $output }
                } -ArgumentList "$TaskPath$TaskName" -ErrorAction Stop
                
                se ($result. ExitCode -eq 0) {
                    $success = $true
                } else {
                    $errorMsg = $result. Saída -join "
                }
            }
        }
    }
    catch {
        $errorMsg = $_. Exception.Message
    }

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

# Main execution Write-Host ""
Write-Host "========================================" -Cyan
ForegroundColor Write-Host " Habilitador de tarefa de atualização de inicialização segura" -ForegroundColor Cyan
Write-Host "========================================" -ForegroundColor Cyan
Write-Host ""
Write-Host "Tarefa: $TaskPath$TaskName" -ForegroundColor Gray
Write-Host ""

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

$results = @()

foreach ($computer in $targets) {     Write-Host "Verificação: $computer" -ForegroundColor Yellow

    $status = Get-SecureBootTaskStatus -Computador $computer

    se ($status. Erro) {
        Write-Host " Erro: $($status. Erro)" -ForegroundColor Red
    }
    elseif (-não $status. TaskExists) {
        Write-Host " Tarefa não existe neste sistema" -ForegroundColor Red

        # Criar se solicitado ou solicitar se Habilitar foi especificado
        $shouldCreate = $Create
        if (-not $shouldCreate -and $Enable) {
            Write-Host ""
            Write-Host " A tarefa pode ter sido excluída." -ForegroundColor Yellow
            se ($Quiet) {
                Write-Host " Tarefa de criação automática (modo silencioso)" -ForegroundColor Cyan
                $shouldCreate = $true
            } else {
                $confirm = Read-Host " Deseja recriar a tarefa?                    (Y/N)"
                se ($confirm -eq 'Y' -ou $confirm -eq 'y') {
                    $shouldCreate = $true
                }
            }
        }

        se ($shouldCreate) {
            Write-Host " Criando tarefa..." -ForegroundColor Yellow
            $createResult = New-SecureBootTask -$computer

de computador             se ($createResult.Success) {
                Write-Host " Tarefa criada com êxito" -ForegroundColor Green
                # Re-marcar status
                $status = Get-SecureBootTaskStatus -Computador $computer

                se ($status. TaskExists) {
                    $stateColor = se ($status. IsEnabled) { "Green" } else { "Red" }
                    Write-Host " State: $($status. TaskState)" -ForegroundColor $stateColor
                }
            }
            else {
                Write-Host " Falha ao criar: $($createResult.Error)" -ForegroundColor Red
            }
        }
    }
    else {
        $stateColor = se ($status. IsEnabled) { "Green" } else { "Red" }
        Write-Host " State: $($status. TaskState)" -ForegroundColor $stateColor

        se ($status. LastRunTime - e $status. LastRunTime -ne [DateTime]::MinValue) {
            Write-Host " Last Run: $($status. LastRunTime)" -ForegroundColor Gray
        }
        se ($status. NextRunTime -e $status. NextRunTime -ne [DateTime]::MinValue) {
            Write-Host " Próxima Execução: $($status. NextRunTime)" -ForegroundColor Gray
        }                                                

        # Enable if requested and currently disabled         se ($Enable -e -não $status. IsEnabled) {
            Write-Host " Tarefa de habilitação..." -ForegroundColor Yellow
            $enableResult = Enable-SecureBootTask -$computer de computador

            if ($enableResult.Success) {
                Write-Host " Tarefa habilitada com êxito" -ForegroundColor Green
                # Re-marcar status
                $status = Get-SecureBootTaskStatus -Computador $computer
            }
            else {
                Write-Host " Falha ao habilitar: $($enableResult.Error)" -ForegroundColor Red
            }
        }
        elseif ($Enable -e $status. IsEnabled) {
            Write-Host " Tarefa já está habilitada" -ForegroundColor Green
        }
    }

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

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

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

Write-Host "Total Checked: $($results.Count)" Write-Host "Habilitado: $enabled" -ForegroundColor Green
se ($disabled -gt 0) { Write-Host "Desabilitado: $disabled" -ForegroundColor Red }
if ($notFound -gt 0) { Write-Host "Not Found: $notFound" -ForegroundColor Yellow }
se ($errors -gt 0) { Write-Host "Erros: $errors" -ForegroundColor Red }

# Return results for pipeline $results