Sample Detect-SecureBootCertUpdateStatus.ps1 script

<# . ANOTACIJA
    Aptinka laivyno stebėjimo saugiosios įkrovos sertifikato naujinimo būseną.

.DESCRIPTION     Šis aptikimo scenarijus renka saugiosios įkrovos būseną, sertifikato naujinimo registro reikšmes,
    ir įrenginio informaciją. Ji pateikia JSON eilutę, skirtą stebėti ir teikti ataskaitas.

    Compatible with Intune Remediations, GPO-based collection, and other management tools.
Taisymo scenarijaus nereikia – jis stebimas tik.

    Exit 0 = "Without issue"  (certificates updated)     Išėjimas 1 = "Problema" (sertifikatai neatnaujinami – tik informaciniai)

.PARAMETER OutputPath     Pasirinktinai. Kelias į aplanką, kuriame bus įrašytas JSON failas.
Jei pateikta, įrašo HOSTNAME_latest.json į šį aplanką.
Jei nepateiktas, išveda JSON į stdout (pradinį veikimą).

.EXAMPLE     # Išvestis į stdout (Intune / SCCM aptikimas)
    .\Detect-SecureBootCertUpdateStatus.ps1

.EXAMPLE     # Įrašyti į bendrai naudojamą tinklo objektą (GPO diegimas)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

.NOTES     Registro keliai pagal https://aka.ms/securebootplaybook:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     ĮSKAITANT, BET NEAPSIRIBOJANT, GARANTIJAS DĖL TINKAMUMO PARDUOTI,
    TINKAMUMAS KONKREČIAM TIKSLUI IR NEFRINGAS. BET KURIUO ATVEJU
    AUTORIAI ARBA AUTORIAUS TEISIŲ TURĖTOJAI BUS ATSAKINGI UŽ BET KOKĮ REIKALAVIMĄ, NUOSTOLIUS AR
    CIVILINĖS TEISĖS PAŽEIDIMĄ AR KITOKIĄ ATSAKOMYBĘ, KYLANČIĄ IŠ,
    PROGRAMINĘ ĮRANGĄ, NAUDOJIMĄ AR KITUS REIKALUS, SUSIJUSIUS
SU PROGRAMINE ĮRANGA,     PROGRAMINĖ ĮRANGA.
#>
param(
    [Parametras(Privalomas = $false)]
    [eilutė]$OutputPath
)

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples" #Pastaba: šis scenarijus vykdomas pabaigos taškams, kad būtų renkami saugiosios įkrovos būsenos duomenys.

# 1. HostName
# PS Versija: Visi | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $hostname = $env:COMPUTERNAME
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Nepavyko nustatyti pagrindinio kompiuterio vardo"
        $hostname = "Nežinoma"
    }
    Write-Host "Hostname: $hostname"
} sugauti {
    Write-Warning "Klaida nuskaitant pagrindinio kompiuterio vardą: $_"
    $hostname = "Klaida"
    Write-Host "Hostname: $hostname"
}

# 2. CollectionTime
# PS Versija: Visi | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $collectionTime = Gavimo data
    jei ($null -eq $collectionTime) {
        Write-Warning "Nepavyko nuskaityti dabartinės datos / laiko"
        $collectionTime = "Nežinoma"
    }
    Write-Host "Collection Time: $collectionTime"
} sugauti {
    Write-Warning "Klaida nuskaitant datą / laiką: $_"
    $collectionTime = "Klaida"
    Write-Host "Collection Time: $collectionTime"
}

# Registry: Secure Boot Main Key (3 values)

# 3. SecureBootEnabled
# PS Versija: 3.0+ | Administratorius: Gali reikėti | Sistemos reikalavimai: UEFI / saugiosios įkrovos palaikanti sistema
išbandykite {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Saugi įkrova įgalinta: $secureBootEnabled"
} sugauti {
    Write-Warning "Nepavyko nustatyti saugiosios įkrovos būsenos naudojant cmdlet: $_"
    # Išbandykite atsarginį
registrą     išbandykite {
        $regValue = Get-ItemProperty -Kelias "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [Bulio logika]$regValue.UEFISecureBootEnabled
        Write-Host "Saugi įkrova įgalinta: $secureBootEnabled"
    } sugauti {
        Write-Warning "Nepavyksta nustatyti saugiosios įkrovos būsenos naudojant registrą. Sistema gali nepalaikyti UEFI / saugiosios įkrovos."
        $secureBootEnabled = $null
        Write-Host "Saugi įkrova įgalinta: nepasiekiama"
    }
}

# 4. HighConfidenceOptOut
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Didelio patikimumo atsisakymas: $highConfidenceOptOut"
} sugauti {
    # HighConfidenceOptOut yra pasirinktinis – daugelyje sistemų
jų nėra     $highConfidenceOptOut = $null
    Write-Host "Didelio patikimumo atsisakymas: nenustatytas"
}

# 4b. MicrosoftUpdateManagedOptIn
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed Opt in: $microsoftUpdateManagedOptIn"
} sugauti {
    # MicrosoftUpdateManagedOptIn yra pasirinktinis – jo nėra daugumoje sistemų
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed Opt in: Not Set"
}

# 5. AvailableUpdates
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Kelias "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    jei ($null -ne $availableUpdates) {
        # Konvertuoti į šešioliktainį formatą
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Available Naujinimai: $availableUpdatesHex"
    } dar {
        Write-Host "Available Naujinimai: Not Available"
    }
} sugauti {
    Write-Warning "AvailableUpdates" registro raktas nerastas arba nepasiekiamas"
    $availableUpdates = $null
    Write-Host "Available Naujinimai: Not Available"
}

# 5b. AvailableUpdatesPolicy (GPO-controlled persistent value)
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Kelias "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    jei ($null -ne $availableUpdatesPolicy) {
        # Konvertuoti į šešioliktainį formatą
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Available Naujinimai Policy: $availableUpdatesPolicyHex"
    } dar {
        Write-Host "Pasiekiama Naujinimai strategija: nenustatyta"
    }
} sugauti {
    # AvailableUpdatesPolicy yra pasirinktinis – nustatomas tik tada, kai taikomas
GPO     $availableUpdatesPolicy = $null
    Write-Host "Available Naujinimai Policy: Not Set"
}

# Registry: Servicing Key (3 values)

# 6. UEFICA2023Status
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 būsena: $uefica 2023Status"
} sugauti {
    Write-Warning "Windows UEFI CA 2023 būsenos registro raktas nerastas arba nepasiekiamas"
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 būsena: nepasiekiama"
}

# 7. UEFICA2023Error
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "UEFI CA 2023 klaida: $uefica 2023Error"
} sugauti {
    # UEFICA2023Klaida yra tik įvykus klaidai – nėra gerai
    $uefica 2023Error = $null
    Write-Host "UEFI CA 2023 klaida: nėra"
}

# 8. UEFICA2023ErrorEvent
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "UEFI CA 2023 klaidos įvykis: $uefica 2023ErrorEvent"
} sugauti {
    $uefica 2023ErrorEvent = $null
    Write-Host "UEFI CA 2023 klaidos įvykis: nepasiekiamas"
}

# Registry: Device Attributes (7 values: 9-15)

# 9. OEMManufacturerName
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([string]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName is empty"
        $oemManufacturerName = "Nežinoma"
    }
    Write-Host "OEM Manufacturer Name: $oemManufacturerName"
} sugauti {
    Write-Warning "OEMManufacturerName" registro raktas nerastas arba nepasiekiamas"
    $oemManufacturerName = $null
    Write-Host "OĮG gamintojo pavadinimas: nepasiekiamas"
}

# 10. OEMModelSystemFamily
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    jei ([eilutė]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily is empty"
        $oemModelSystemFamily = "Nežinoma"
    }
    Write-Host "OEM Model System Family: $oemModelSystemFamily"
} sugauti {
    Write-Warning "OEMModelSystemFamily registro raktas nerastas arba nepasiekiamas"
    $oemModelSystemFamily = $null
    Write-Host "OEM Model System Family: Not Available"
}

# 11. OEMModelNumber
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    jei ([eilutė]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber is empty"
        $oemModelNumber = "Nežinoma"
    }
    Write-Host "OEM Model Number: $oemModelNumber"
} sugauti {
    Write-Warning "OEMModelNumber registro raktas nerastas arba nepasiekiamas"
    $oemModelNumber = $null
    Write-Host "OĮG modelio numeris: nepasiekiamas"
}

# 12. FirmwareVersion
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    jei ([eilutė]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion" tuščias"
        $firmwareVersion = "Nežinoma"
    }
    Write-Host "Programinės-aparatinės įrangos versija: $firmwareVersion"
} sugauti {
    Write-Warning "FirmwareVersion" registro raktas nerastas arba nepasiekiamas"
    $firmwareVersion = $null
    Write-Host "Programinės-aparatinės įrangos versija: nepasiekiama"
}

# 13. FirmwareReleaseDate
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    jei ([eilutė]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate is empty"
        $firmwareReleaseDate = "Nežinoma"
    }
    Write-Host "Programinės-aparatinės įrangos išleidimo data: $firmwareReleaseDate"
} sugauti {
    Write-Warning "FirmwareReleaseDate registro raktas nerastas arba nepasiekiamas"
    $firmwareReleaseDate = $null
    Write-Host "Programinės-aparatinės įrangos išleidimo data: nepasiekiama"
}

# 14. OSArchitecture
# PS Versija: Visi | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    jei ([eilutė]::IsNullOrEmpty($osArchitecture)) {
        # Išbandykite atsarginį
registrą         $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    jei ([eilutė]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "Nepavyko nustatyti OSArchitecture"
        $osArchitecture = "Nežinoma"
    }
    Write-Host "OS Architecture: $osArchitecture"
} sugauti {
    Write-Warning "Klaida nuskaitant OSArchitecture: $_"
    $osArchitecture = "Nežinoma"
    Write-Host "OS Architecture: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS Versija: Visi | Administratorius: Gali reikėti | Sistemos reikalavimai: nėra
išbandykite {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Konvertuoti FILETIME į UTC DateTime – registro saugyklos kaip REG_BINARY (baitas[]) arba REG_QWORD (ilgas)
    jei ($null -ne $canAttemptUpdateAfter) {
        išbandykite {
            jei ($canAttemptUpdateAfter -yra [baitas[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } sugauti {
            Write-Warning "Nepavyko konvertuoti CanAttemptUpdateAfter FILETIME į DateTime"
        }
    }
    Write-Host "Gali bandyti atnaujinti po: $canAttemptUpdateAfter"
} sugauti {
    Write-Warning "CanAttemptUpdateAfter registro raktas nerastas arba nepasiekiamas"
    $canAttemptUpdateAfter = $null
    Write-Host "Gali bandyti atnaujinti po: nepasiekiama"
}

# Event Logs: System Log (10 values: 16-25)

# 16-25. Event Log queries
# Įvykio ID:
# 1801 – pradėtas naujinimas, būtinas perkrovimas
# 1808 – naujinimas sėkmingai
baigtas # 1795 – pateikta programinės-aparatinės įrangos klaida (užfiksuoti klaidos kodą)
# 1796 – klaida užregistruota su klaidos kodu (fiksavimo kodas)
# 1800 – reikalingas paleidimas iš naujo (NE klaida – naujinimas bus tęsiamas paleidus iš naujo)
# 1802 – žinoma programinės-aparatinės įrangos problema, užblokuotas naujinimas ("SkipReason" užfiksuoti KI_<numerį>)
# 1803 – atitinkantis KEK naujinimas nerastas (OĮG turi pateikti PK pasirašytą KEK)
# PS Versija: 3.0+ | Administratorius: gali reikėti sistemos žurnalui | Sistemos reikalavimai: nėra
išbandykite {
    # Užklausti visus susijusius saugiosios įkrovos
įvykio ID     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    if ($events.Count -eq 0) {         Write-Warning "Sistemos žurnale nerasta saugiosios įkrovos įvykių"
        $latestEventId = $null
        $bucketId = $null
        $confidence = $null
        $skipReasonKnownIssue = $null
        $event 1801Count = 0
        $event 1808Count = 0
        $event 1795Count = 0
        $event 1795ErrorCode = $null
        $event 1796Count = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Count = 0
        $missingKEK = $false
        Write-Host "Naujausias įvykio ID: nepasiekiamas"
        Write-Host "Talpyklos ID: nepasiekiamas"
        Write-Host "Patikimumas: nepasiekiamas"
        Write-Host "1801 įvykis: 0"
        Write-Host "Event 1808 Count: 0"
    } dar {
        # 16. Vėliausi eventId
        $latestEvent = $events | Sort-Object TimeCreated -Descending | Select-Object – pirmas 1
        jei ($null -eq $latestEvent) {
            Write-Warning "Nepavyko nustatyti naujausio įvykio"
            $latestEventId = $null
            Write-Host "Vėliausio įvykio ID: nepasiekiamas"
        } dar {
            $latestEventId = $latestEvent.Id
            Write-Host "Naujausias įvykio ID: $latestEventId"
        }

        # 17. BucketID - Extracted from Event 1801/1808
jei ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            jei ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trim()
                Write-Host "Segmento ID: $bucketId"
            } dar {
                Write-Warning "BucketId nerastas įvykio pranešime"
                $bucketId = $null
                Write-Host "Segmento ID: nerastas įvykyje"
            }
        } dar {
            Write-Warning "Naujausias įvykis arba pranešimas yra nulinis, negalima išskleisti BucketId"
            $bucketId = $null
            Write-Host "Talpyklos ID: nepasiekiamas"
        }

        # 18. Confidence - Extracted from Event 1801/1808
jei ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            jei ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trim()
                Write-Host "Pasitikėjimas: $confidence"
            } dar {
                Write-Warning "Patikimumo lygis nerastas įvykio pranešime"
                $confidence = $null
                Write-Host "Pasitikėjimas: nerastas įvykyje"
            }
        } dar {
            Write-Warning "Naujausias įvykis arba pranešimas yra nulinis, negalima išskleisti patikimumo"
            $confidence = $null
            Write-Host "Patikimumas: nepasiekiamas"
        }

        # 18b. SkipReason - Extract KI_<number> from SkipReason in the same event as BucketId
# Tai fiksuoja žinomų problemų ID, kurie rodomi kartu su BucketId / confidence (ne tik 1802 įvykis)
        $skipReasonKnownIssue = $null
        jei ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            jei ($latestEvent.Message -match 'SkipReason:\s*(KI_\d+)') {
                $skipReasonKnownIssue = $matches[1]
                Write-Host "SkipReason" žinoma problema: $skipReasonKnownIssue" – priekinio planopalva geltona
            }
        }

        # 19. Event1801Count
$event 1801Array = @($events | Where-Object {$_. Id -eq 1801})
        $event 1801Count = $event 1801Array.Count
        Write-Host "Event 1801 Count: $event 1801Count"

        # 20. Event1808Count
$event 1808Array = @($events | Where-Object {$_. Id -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Event 1808 Count: $event 1808Count"
        
        # Inicijuoti klaidos įvykio kintamuosius
        $event 1795Count = 0
        $event 1795ErrorCode = $null
        $event 1796Count = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Count = 0
        $missingKEK = $false
        
        # Tik patikrinkite, ar nėra klaidų įvykių, jei naujinimas NEBAIGTAS
        # Praleisti klaidos analizę, jei: 1808 yra naujausias įvykis ARBA UEFICA2023Status yra "Atnaujinta"
        $updateComplete = ($latestEventId -eq 1808) -or ($uefica 2023Status -eq "Atnaujinta")
        
        jei (-not $updateComplete) {
            Write-Host "Naujinimas nebaigtas – tikrinama, ar yra klaidų įvykių..." -Priekinio planopalva geltona
            
            # 21. Event1795 – programinės-aparatinės įrangos klaida (fiksavimo klaidos kodas)
            $event 1795Array = @($events | Where-Object {$_. Id -eq 1795})
            $event 1795Count = $event 1795Array.Count
            jei ($event 1795Count -gt 0) {
                $latestEvent 1795 = $event 1795Array | Sort-Object TimeCreated -Descending | Select-Object – pirmas 1
                if ($latestEvent 1795.Message -match '(?:error|code|status)[:\s]*(?:0x)?( [0-9A-Fa-f]{8}|[0-9A-Fa-f]+)') {
                    $event 1795ErrorCode = $matches[1]
                }
                Write-Host "Įvykių 1795 (programinės-aparatinės įrangos klaida) skaičius: $event 1795Count" $(if ($event 1795ErrorCode) { "Kodas: $event 1795ErrorCode" })
            }
            
            # 22. Event1796 – užregistruotas klaidos kodas (įrašymo klaidos kodas)
            $event 1796Array = @($events | Where-Object {$_. Id -eq 1796})
            $event 1796Count = $event 1796Array.Count
            jei ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object TimeCreated -Descending | Select-Object – pirmas 1
                if ($latestEvent 1796.Message -match '(?:error|code|status)[:\s]*(?:0x)?( [0-9A-Fa-f]{8}|[0-9A-Fa-f]+)') {
                    $event 1796ErrorCode = $matches[1]
                }
                Write-Host "Event 1796 (Error Logged) Count: $event 1796Count" $(if ($event 1796ErrorCode) { "Code: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 – reikalingas paleidimas iš naujo (NE klaida – naujinimas bus tęsiamas paleidus iš naujo)
            $event 1800Array = @($events | Where-Object {$_. Id -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            jei ($rebootPending) {
                Write-Host "Event 1800 (Pending Reboot Pending): Update will proceed after reboot" -ForegroundColor Cyan
            }
            
            # 24. Event1802 – žinomos programinės-aparatinės įrangos problema ("SkipReason"> surinkimo KI_<numeris)
            $event 1802Array = @($events | Where-Object {$_. Id -eq 1802})
            $event 1802Count = $event 1802Array.Count
            jei ($event 1802Count -gt 0) {
                $latestEvent 1802 = $event 1802Array | Sort-Object TimeCreated -Descending | Select-Object – pirmas 1
                jei ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Įvykių 1802 (žinomos programinės-aparatinės įrangos problema) skaičius: $event 1802Count" $(jei ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 – trūksta KEK naujinimo (OĮG turi pateikti PK pasirašytą KEK)
            $event 1803Array = @($events | Where-Object {$_. Id -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            jei ($missingKEK) {
                Write-Host "Event 1803 (Missing KEK): OEM needs to supply PK signed KEK" -ForegroundColor Yellow
            }
        } dar {
            Write-Host "Naujinimas baigtas (1808 įvykis arba būsena=atnaujinta) – praleidžiama klaidų analizė" -Priekinio planopalva žalia
        }
    }
} sugauti {
    Write-Warning "Klaida nuskaitant įvykių žurnalus. Gali reikėti administratoriaus teisių: $_"
    $latestEventId = $null
    $bucketId = $null
    $confidence = $null
    $skipReasonKnownIssue = $null
    $event 1801Count = 0
    $event 1808Count = 0
    $event 1795Count = 0
    $event 1795ErrorCode = $null
    $event 1796Count = 0
    $event 1796ErrorCode = $null
    $event 1800Count = 0
    $rebootPending = $false
    $event 1802Count = 0
    $knownIssueId = $null
    $event 1803Count = 0
    $missingKEK = $false
    Write-Host "Naujausias įvykio ID: klaida"
    Write-Host "Talpyklos ID: klaida"
    Write-Host "Pasitikėjimas: klaida"
    Write-Host "1801 įvykis: 0"
    Write-Host "1808 įvykis: 0"
}

# WMI/CIM Queries (5 values)

# 26. OSVersion
# PS versija: 3.0+ (naudokite Get-WmiObject 2.0 versijai) | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -arba [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nepavyko nuskaityti OS versijos"
        $osVersion = "Nežinoma"
    } dar {
        $osVersion = $osInfo.Version
    }
    Write-Host "OS versija: $osVersion"
} sugauti {
    # CIM gali nepavykti kai kuriose aplinkose – naudokite atsarginę
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Nežinoma" }
    Write-Host "OS versija: $osVersion"
}

# 27. LastBootTime
# PS versija: 3.0+ (naudokite Get-WmiObject 2.0 versijai) | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    jei ($null -eq $osInfo arba $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nepavyko gauti paskutinės įkrovos laiko"
        $lastBootTime = $null
        Write-Host "Paskutinės įkrovos laikas: nepasiekiama"
    } dar {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Paskutinio paleidimo laikas: $lastBootTime"
    }
} sugauti {
    # CIM gali nepavykti kai kuriose aplinkose – naudokite atsarginę
    išbandykite {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Pradžios laikas
    } sugauti {
        $lastBootTime = $null
    }
    jei ($lastBootTime) { Write-Host "Paskutinės įkrovos laikas: $lastBootTime" } dar { Write-Host "Paskutinio paleidimo laikas: nepasiekiama" }
}

# 28. BaseBoardManufacturer
# PS versija: 3.0+ (naudokite Get-WmiObject 2.0 versijai) | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    jei ($null -eq $baseBoard arba [eilutė]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Nepavyko nuskaityti bazinių lentų gamintojo"
        $baseBoardManufacturer = "Nežinoma"
    } dar {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
} sugauti {
    # CIM gali nepavykti – bazinių lentų informacija yra papildoma
    $baseBoardManufacturer = "Nežinoma"
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS versija: 3.0+ (naudokite Get-WmiObject 2.0 versijai) | Administratorius: Ne | Sistemos reikalavimai: nėra
išbandykite {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -arba [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nepavyko nuskaityti baseboard produkto"
        $baseBoardProduct = "Nežinoma"
    } dar {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Baseboard Product: $baseBoardProduct"
} sugauti {
    # CIM gali nepavykti – bazinių lentų informacija yra papildoma
    $baseBoardProduct = "Nežinoma"
    Write-Host "Baseboard Product: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS Versija: Visi | Administratorius: Ne | Sistemos reikalavimai: suplanuota užduotis
yra # Tikrina, ar įgalinta saugiosios įkrovos naujinimo suplanuota užduotis
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Nežinoma"
išbandykite {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    jei ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | ConvertFrom-Csv
        jei ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
        }
    } dar {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    jei ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -ForegroundColor Yellow
    } dar {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -ForegroundColor Green
    }
} sugauti {
    $secureBootTaskStatus = "Klaida"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. WinCS Key Status (F33E0C8E002 - Secure Boot Certificate Update)
# PS Versija: Visi | Administratorius: Taip (užklausai) | Sistemos reikalavimai: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Nežinoma"
išbandykite {
    # Patikrinkite bendras vietas, kuriose yra WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p in $possiblePaths) {
        if (Test-Path $p) { $wincsFlagsPath = $p; break }
    }

    jei ($wincsFlagsPath) {
        # Užklausai būdingas raktas – būtinos administratoriaus teisės
        $queryOutput = & $wincsFlagsPath /query – rakto F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        jei ($LASTEXITCODE -eq 0) {
            # Patikrinkite, ar pritaikytas raktas (ieškokite "Active Configuration" arba panašaus indikatoriaus)
            jei ($queryOutputStr -atitinka "Active Configuration.*:*enabled" -arba $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Pritaikyta"
                Write-Host "WinCS" klavišų F33E0C8E002: pritaikytas" – priekinio planopalva žalia
            } elseif ($queryOutputStr -match nerasta|Konfigūracijos nėra") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS" klavišų F33E0C8E002: netaikoma" – priekinio planopalva geltona
            } dar {
                # Kodas yra - tikrinti būsenos
išvestį                 $wincsKeyApplied = $true
                $wincsKeyStatus = "Pritaikyta"
                Write-Host "WinCS key F33E0C8E002: Applied" –Priekinio planopalva žalia
            }
        } dar {
            # Patikrinkite, ar yra konkrečių klaidų pranešimų
            jei ($queryOutputStr -atitinka "Prieiga uždrausta|administratorius") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS key F33E0C8E002: Access denied (run as admin)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match nerasta|Konfigūracijos nėra") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS" klavišų F33E0C8E002: netaikoma" – priekinio planopalva geltona
            } dar {
                $wincsKeyStatus = "Užklausa nepavyko"
                Write-Host "WinCS rakto F33E0C8E002: užklausa nepavyko" -Priekinio planopalva raudona
            }
        }
    } dar {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS key F33E0C8E002: WinCsFlags.exe not found" -ForegroundColor Gray
    }
} sugauti {
    $wincsKeyStatus = "Klaida"
    Write-Host "WinCS key F33E0C8E002: Error checking - $_" -ForegroundColor Red
}              

# ============================================================================= # Atkūrimo aptikimas – būsenos išvestis & išėjimo kodas
# =============================================================================

# Build status object from all collected inventory data $status = [sutvarkyta]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Error = $uefica 2023Error
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = if ($null -ne $availableUpdates) { $availableUpdatesHex } else { $null }
    AvailableUpdatesPolicy = jei ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } dar { $null }
    Pagrindinio kompiuterio vardas = $hostname
    CollectionTime = if ($collectionTime -is [datetime]) { $collectionTime.ToString("o") } else { "$collectionTime" }
    SecureBootEnabled = $secureBootEnabled
    HighConfidenceOptOut = $highConfidenceOptOut
    MicrosoftUpdateManagedOptIn = $microsoftUpdateManagedOptIn
    OEMManufacturerName = $oemManufacturerName
    OEMModelSystemFamily = $oemModelSystemFamily
    OEMModelNumber = $oemModelNumber
    FirmwareVersion = $firmwareVersion
    FirmwareReleaseDate = $firmwareReleaseDate
    OSArchitecture = $osArchitecture
    CanAttemptUpdateAfter = if ($canAttemptUpdateAfter -is [datetime]) { $canAttemptUpdateAfter.ToString("o") } else { "$canAttemptUpdateAfter" }
    LatestEventId = $latestEventId
    BucketId = $bucketId
    Patikimumas = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<skaičius,> iš SkipReason BucketId įvykyje
    Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Klaidos įvykiai su užfiksuotą išsamia informacija
    Event1795Count = $event 1795Count # grąžinta programinė-aparatinė įranga klaida
    Event1795ErrorCode = $event 1795ErrorCode # klaidos kodas iš programinės-aparatinės įrangos
    Event1796Count = $event 1796Count # užregistruotas
klaidos kodas     Event1796ErrorCode = $event 1796ErrorCode # Užfiksuotas klaidos kodas
    Event1800Count = $event 1800Count # Reikalingas perkrovimas (NE klaida)
    RebootPending = $rebootPending # True, jei 1800 įvykis yra
    Event1802Count = $event 1802Count # žinoma programinės-aparatinės įrangos problema
    KnownIssueId = $knownIssueId # KI_<skaičius,> skipReason
    Event1803Count = $event 1803Count # Trūksta KEK naujinimo
    MissingKEK = $missingKEK # OEM reikia pateikti PK pasirašytą KEK
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True, jei taikomas
F33E0C8E002 raktas     WinCSKeyStatus = $wincsKeyStatus # Pritaikyta, NotApplied, WinCsFlagsNotFound ir kt.
}

# Output the status - For data aggregation $jsonOutput = $status | ConvertTo-Json – glaudinti

# If OutputPath provided, save to file; otherwise output to stdout jei (-not [eilutė]::IsNullOrEmpty($OutputPath)) {
    #Validate OutputPath – praleisti, jei ji atrodo kaip žinyno užklausa arba joje yra neleistinų simbolių
    jei ($OutputPath -atitinka ^[/\-]' -arba $OutputPath -match '[<>:"|? *]') {
        Write-Host "Nurodyta neleistina OutputPath, išvestis į stdout" -Priekinio planopalva Geltona
       
Write-Output $jsonOutput         jei ($secureBootEnabled -and $uefica 2023Status -eq "Atnaujinta") { išeiti 0 } dar { išeiti 1 }
    }

    # Įsitikinkite, kad išvesties aplankas
yra     jei (-not (testo kelias $OutputPath)) {
        išbandykite {
            New-Item -ItemType katalogas - Kelias $OutputPath -Force | Nu neapibrėžta reikšmė (Out-Null)
        } sugauti {
            Write-Warning "Nepavyko sukurti išvesties aplanko: $OutputPath – $_"
        }
    }

    # Įrašyti į HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    išbandykite {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } sugauti {
        Write-Warning "Nepavyko rašyti į failą: $outputFile - $_"
        # Grįžti į stdout
       
Write-Output $jsonOutput     }
} dar {
    # Pradinis veikimas – išvestis į stdout
   
Write-Output $jsonOutput }          

# Exit code: "Updated" is the success value per the playbook jei ($secureBootEnabled ir $uefica 2023Status -eq "Atnaujinta") {
    išeiti 0 # be problemų
} dar {
    exit 1 # With issue
}