Vzorový skript zhromažďovania údajov inventára zabezpečeného spustenia

<#
. PREHĽADU
    Zisťuje stav aktualizácie certifikátu zabezpečeného spustenia na monitorovanie celého vozového parku.

. POPIS / KONTROL
    Tento detekčný skript zhromažďuje stav zabezpečeného spustenia, hodnoty databázy Registry aktualizácie certifikátu,
    a informácie o zariadení. Výstupom je reťazec JSON na monitorovanie a vytváranie zostáv.

    Kompatibilné s Intune nápravami, kolekciou založenou na objekte GPO a ďalšími nástrojmi na správu.
Nie je potrebný žiadny opravný skript – toto je len monitorovanie.

    Ukončiť 0 = "Bez problému" (aktualizované certifikáty)
    Exit 1 = "With issue" (certifikáty sa neaktualizovali – iba informačné)

. PARAMETER OutputPath
    Voliteľné. Cesta k priečinku, do ktorého sa uloží súbor JSON.
Ak je k dispozícii, uloží HOSTNAME_latest.json do tohto priečinka.
Ak nie je poskytnutá, výstupY JSON na stdout (pôvodné správanie).

. PRÍKLAD
    # Výstup do stdout (detekcia Intune/SCCM)
    .\Detect-SecureBootCertUpdateStatus.ps1

. PRÍKLAD
    # Uložiť do zdieľaného sieťového umiestnenia (nasadenie objektu GPO)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. POZNÁMKY
    Cesty databázy Registry na https://aka.ms/securebootplaybook:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    SOFTVÉR JE POSKYTNUTÝ "TAK, AKO JE", BEZ ZÁRUKY AKÉHOKOĽVEK DRUHU, VYJADRIŤ ALEBO
    VRÁTANE ZÁRUK OBCHODOVATEĽNOSTI, VRÁTANE ZÁRUK OBCHODOVATEĽNOSTI,
    VHODNOSTI NA KONKRÉTNY ÚČEL A NONINFRINGEMENT. V ŽIADNOM
PRÍPADE     AUTORI ALEBO DRŽITELIA AUTORSKÝCH PRÁV SÚ ZODPOVEDNÍ ZA AKÉKOĽVEK NÁROKY, ŠKODY ALEBO INÉ
    ZODPOVEDNOSTI, ČI UŽ V RÁMCI ZMLUVNÉHO KONANIA, DELIKTU ALEBO INAK, VYPLÝVAJÚCEHO Z
    ALEBO V SÚVISLOSTI SO SOFTVÉROM ALEBO POUŽÍVANÍM ALEBO INÝMI OBCHODMI
    SOFTVÉR.
#>
param(
    [Parameter(Povinné = $false)]
    [reťazec]$OutputPath
)

# Stiahnuť URL: https://aka.ms/getsecureboot -> "Nasadenie a monitorovanie Ukážky"
# Poznámka: Tento skript sa spúšťa v koncových bodoch na zhromažďovanie údajov o stave zabezpečeného spustenia.

# 1. Hostname
# PS Verzia: Všetky | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $hostname = $env:COMPUTERNAME
    if ([reťazec]::IsNullOrEmpty($hostname)) {
        Write-Warning "Názov hostiteľa sa nepodarilo určiť"
        $hostname = "Neznáme"
    }
    Write-Host "Hostname: $hostname" (Názov hostiteľa: $hostname)
} chytiť {
    Write-Warning "Chyba pri načítavaní názvu hostiteľa: $_"
    $hostname = "Chyba"
    Write-Host "Hostname: $hostname" (Názov hostiteľa: $hostname)
}

# 2.
Čas kolekcie # PS Verzia: Všetky | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $collectionTime = Get-Date
    if ($null -eq $collectionTime) {
        Write-Warning "Nepodarilo sa načítať aktuálny dátum a čas"
        $collectionTime = "Neznáme"
    }
    Write-Host "Čas kolekcie: $collectionTime"
} chytiť {
    Write-Warning "Chyba pri načítavaní dátumu a času: $_"
    $collectionTime = "Chyba"
    Write-Host "Čas kolekcie: $collectionTime"
}

# Registry: Secure Boot Hlavný kľúč (3 hodnoty)

# 3. SecureBootEnabled
# PS Verzia: 3.0 + | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Systém
UEFI/Zabezpečené spustenie vyskúšať {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Secure Boot Enabled: $secureBootEnabled" (Povolené zabezpečené spustenie: $secureBootEnabled)
} chytiť {
    Write-Warning "Nedá sa určiť stav zabezpečeného spustenia prostredníctvom rutiny typu cmdlet: $_"
    # Skúste záložnú
akciu databázy Registry     vyskúšať {
        $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Zabezpečené spustenie povolené: $secureBootEnabled"
    } chytiť {
        Write-Warning "Nepodarilo sa určiť stav zabezpečeného spustenia prostredníctvom databázy Registry. Systém nemusí podporovať UEFI/Zabezpečené spustenie."
        $secureBootEnabled = $null
        Write-Host "Zabezpečené spustenie povolené: nie je k dispozícii"
    }
}

# 4. HighConfidenceOptOut
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "High Confidence Opt Out: $highConfidenceOptOut"
} chytiť {
    # HighConfidenceOptOut je voliteľný - nie je prítomný vo väčšine systémov
    $highConfidenceOptOut = $null
    Write-Host "High Confidence Opt Out: Not Set"
}

Č. 4b. MicrosoftUpdateManagedOptIn
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed opt in: $microsoftUpdateManagedOptIn"
} chytiť {
    # MicrosoftUpdateManagedOptIn je voliteľný - nie je prítomný vo väčšine systémov
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed opt in: Not Set" (Explicitný súhlas spravovanej služby Microsoft Update: Nie je nastavený)
}

# 5. Dostupné súhrny
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Konvertovať na šestnástkové formáty
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host Dostupné Aktualizácie: $availableUpdatesHex
    } else {
        Write-Host Dostupné Aktualizácie: Nie je k dispozícii
    }
} chytiť {
    Write-Warning "Kľúč databázy Registry AvailableUpdates sa nenašiel alebo je nedostupný"
    $availableUpdates = $null
    Write-Host "K dispozícii Aktualizácie: Nie je k dispozícii"
}

Č. 5b. AvailableUpdatesPolicy (trvalá hodnota riadená objektom GPO)
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Konvertovať na šestnástkové formáty
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Dostupná politika Aktualizácie: $availableUpdatesPolicyHex"
    } else {
        Write-Host "K dispozícii politika Aktualizácie: Nie je nastavená"
    }
} chytiť {
    # AvailableUpdatesPolicy je voliteľná – nastaví sa len pri použití
objektu GPO     $availableUpdatesPolicy = $null
    Write-Host "K dispozícii politika Aktualizácie: Nenastaví sa"
}

# Registry: Servicing Key (3 hodnoty)

# 6. UEFICA2023Status
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 Status: $uefica 2023Status"
} chytiť {
    Write-Warning "Kľúč databázy Registry stavu Windows UEFI CA 2023 sa nenašiel alebo je neprístupný"
    $uefica 2023Status = $null
    Write-Host "Stav Windows UEFI CA 2023: Nie je k dispozícii"
}

# 7. UEFICA2023Chyba
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Chyba = $regValue.UEFICA2023Chyor
    Write-Host "Chyba UEFI CA 2023: $uefica 2023Chyba"
} chytiť {
    # UEFICA2023Chyba existuje len vtedy, ak došlo k chybe - absencia je dobrá
    $uefica 2023Chyba = $null
    Write-Host "Chyba UEFI CA 2023: Žiadne"
}

# 8. UEFICA2023ErrorEvent
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "Udalosť chyby UEFI CA 2023: $uefica 2023ErrorEvent"
} chytiť {
    $uefica 2023ErrorEvent = $null
    Write-Host "Udalosť chyby UEFI CA 2023: Nie je k dispozícii"
}

# Registry: Atribúty zariadenia (7 hodnôt: 9-15)

# 9. Názov OEMManufacturerName
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([reťazec]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName je prázdne"
        $oemManufacturerName = "Neznáme"
    }
    Write-Host "Názov výrobcu výrobcu OEM: $oemManufacturerName"
} chytiť {
    Write-Warning "Kľúč databázy Registry OEMManufacturerName sa nenašiel alebo je nedostupný"
    $oemManufacturerName = $null
    Write-Host "Názov výrobcu OEM: Nie je k dispozícii"
}

# 10. OEMModelSystemFamily
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([reťazec]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily je prázdne"
        $oemModelSystemFamily = Neznáme
    }
    Write-Host "OEM Model System Family: $oemModelSystemFamily"
} chytiť {
    Write-Warning "Kľúč databázy Registry OEMModelSystemFamily sa nenašiel alebo je nedostupný"
    $oemModelSystemFamily = $null
    Write-Host "OEM Model System Family: Not Available"
}

# 11. Číslo OEMModelNumber
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([reťazec]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber is empty" (Číslo OEMModelNumber je prázdne)
        $oemModelNumber = "Neznáme"
    }
    Write-Host "Číslo modelu OEM: $oemModelNumber"
} chytiť {
    Write-Warning "Kľúč databázy Registry OEMModelNumber sa nenašiel alebo je nedostupný"
    $oemModelNumber = $null
    Write-Host "Číslo modelu OEM: Nie je k dispozícii"
}

# 12.
Verzia firmvéru # PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([reťazec]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion is empty" (Verzia Firmvéru je prázdna)
        $firmwareVersion = "Neznáme"
    }
    Write-Host Verzia firmvéru: $firmwareVersion
} chytiť {
    Write-Warning "Kľúč databázy Registry FirmwareVersion sa nenašiel alebo je neprístupný"
    $firmwareVersion = $null
    Write-Host Verzia firmvéru: Nie je k dispozícii
}

# 13. FirmwareReleaseDate
(Dátum Firmvéru) # PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([reťazec]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate is empty"
        $firmwareReleaseDate = "Neznáme"
    }
    Write-Host "Firmware Release Date: $firmwareReleaseDate"
} chytiť {
    Write-Warning "FirmwareReleaseDate kľúč databázy Registry sa nenašiel alebo neprístupný"
    $firmwareReleaseDate = $null
    Write-Host "Firmware Release Date: Not Available"
}

# 14. OSArchitecture
# PS Verzia: Všetky | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([reťazec]::IsNullOrEmpty($osArchitecture)) {
        # Skúste záložnú
akciu databázy Registry         $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([reťazec]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture sa nepodarilo určiť"
        $osArchitecture = "Neznáme"
    }
    Write-Host "Architektúra operačného systému: $osArchitecture"
} chytiť {
    Write-Warning "Chyba pri načítavaní OSArchitecture: $_"
    $osArchitecture = "Neznáme"
    Write-Host Architektúra operačného systému: $osArchitecture
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS Verzia: Všetky | Spravovanie: Môže sa vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Konvertovať FILETIME na UTC DateTime – ukladacie priestory databázy Registry ako REG_BINARY (bajt[]) alebo REG_QWORD (long)
    if ($null -ne $canAttemptUpdateAfter) {
        vyskúšať {
            if ($canAttemptUpdateAfter -is [bajt[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } chytiť {
            Write-Warning "Nedá sa konvertovať CanAttemptUpdateAfter FILETIME na DateTime"
        }
    }
    Write-Host "Môže sa pokúsiť o aktualizáciu po: $canAttemptUpdateAfter"
} chytiť {
    Write-Warning "CanAttemptUpdateAfter kľúč databázy Registry sa nenašiel alebo je nedostupný"
    $canAttemptUpdateAfter = $null
    Write-Host "Môže sa pokúsiť o aktualizáciu po: Nie je k dispozícii"
}

# Denníky udalostí: Denník systému (10 hodnôt: 16-25)

# 16-25. Dotazy denníka udalostí
# IDENTIFIKÁCIE udalostí:
# 1801 - Aktualizácia spustená, vyžaduje
sa reštart # 1808 - Aktualizácia sa úspešne dokončila
# 1795 - Firmware vrátil chybu (zachytiť kód chyby)
# 1796 - Chyba zaznamenaná s kódom chyby (zachytiť kód)
# 1800 - Vyžaduje sa reštart (NOT chyba - aktualizácia bude pokračovať po reštarte)
# 1802 - Známy problém firmvéru zablokované aktualizácie (zachytiť KI_<číslo> z SkipReason)
# 1803 - Zodpovedajúce KEK aktualizácia nenašla (OEM musí dodávať PK podpísané KEK)
# PS Verzia: 3.0 + | Spravovanie: Denník systému sa môže vyžadovať | Systémové požiadavky: Žiadne
vyskúšať {
    # Dotazovať všetky relevantné IDENTIFIKÁCIE
udalostí zabezpečeného spustenia     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    ak ($events. Počet -eq 0) {
        Write-Warning "Nenašli sa žiadne udalosti zabezpečeného spustenia v denníku systému"
        $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 "Identifikácia poslednej udalosti: Nie je k dispozícii"
        Write-Host "Bucket ID: Not Available" (Id sektora: nie je k dispozícii)
        Write-Host "Spoľahlivosť: Nie je k dispozícii"
        Write-Host "Event 1801 Count: 0"
        Write-Host "Event 1808 Count: 0"
    } else {
        # 16. Posledná IdentifikáciaUdalosti
        $latestEvent = $events | Sort-Object timecreated -descending | Select-Object – prvá 1
        if ($null -eq $latestEvent) {
            Write-Warning "Nepodarilo sa určiť najnovšiu udalosť"
            $latestEventId = $null
            Write-Host "Identifikácia poslednej udalosti: Nie je k dispozícii"
        } else {
            $latestEventId = $latestEvent.Id
            Write-Host "Identifikácia poslednej udalosti: $latestEventId"
        }

        # 17. BucketID – extrahované z udalosti 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Orezanie()
                Write-Host "Bucket ID: $bucketId"
            } else {
                Write-Warning "BucketId sa nenašiel v hlásení udalosti"
                $bucketId = $null
                Write-Host "Bucket ID: Not Found in Event"
            }
        } else {
            Write-Warning "Posledná udalosť alebo správa má hodnotu null, nemôže extrahovať BucketId"
            $bucketId = $null
            Write-Host "Bucket ID: Not Available"
        }

        # 18. Spoľahlivosť – extrahované z udalosti 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Orezanie()
                Write-Host "Spoľahlivosť: $confidence"
            } else {
                Write-Warning "Confidence level not found in event message" (Úroveň spoľahlivosti sa nenašla v hlásení udalosti)
                $confidence = $null
                Write-Host "Confidence: Not Found in Event" (Spoľahlivosť: nenašla sa v udalosti)
            }
        } else {
            Write-Warning "Posledná udalosť alebo správa má hodnotu null, nemôže extrahovať spoľahlivosť"
            $confidence = $null
            Write-Host "Spoľahlivosť: Nie je k dispozícii"
        }

        Č. 18b. SkipReason - extrahovať KI_<číslo> z SkipReason v rovnakej udalosti ako BucketId
        # Táto udalosť zachytáva id známych problémov, ktoré sa zobrazujú vedľa kontajnera BucketId/Confidence (nielen udalosť 1802)
        $skipReasonKnownIssue = $null
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'SkipReason:\s*(KI_\d+)') {
                $skipReasonKnownIssue = $matches[1]
                Write-Host "SkipReason Known Issue: $skipReasonKnownIssue" -ForegroundColor Yellow
            }
        }

        # 19. Počet udalostí1801
        $event 1801Array = @($events | Where-Object {$_. Identifikácia -eq 1801})
        $event 1801Count = $event 1801Array.Count
        Write-Host "Event 1801 Count: $event 1801Count"

        # 20. Počet udalostí1808
        $event 1808Array = @($events | Where-Object {$_. Identifikácia -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Event 1808 Count: $event 1808Count"
        
        # Inicializovať premenné
udalostí chyby         $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
        
        # Skontrolujte iba výskyt udalostí chýb, ak nie je aktualizácia dokončená
        # Vynechať analýzu chýb, ak: 1808 je posledná udalosť ALEBO UEFICA2023Status je "Aktualizované"
        $updateComplete = ($latestEventId -eq 1808) -or ($uefica 2023Status -eq "Aktualizované")
        
        ak (-nie $updateComplete) {
            Write-Host "Update not complete - checking for error events..." -ForegroundColor Yellow
            
            # 21. Udalosť1795 – chyba firmvéru (zaznamenať kód chyby)
            $event 1795Array = @($events | Where-Object {$_. Identifikácia -eq 1795})
            $event 1795Count = $event 1795Array.Count
            if ($event 1795Count -gt 0) {
                $latestEvent 1795 = $event 1795Array | Sort-Object TimeCreated -Descending | Select-Object – prvá 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 "Udalosť 1795 (chyba firmvéru) Počet: $event 1795Count" $(if ($event 1795ErrorCode) { "Code: $event 1795ErrorCode" })
            }
            
            # 22. Udalosť1796 – kód chyby sa zapísal do denníka (zaznamenať kód chyby)
            $event 1796Array = @($events | Where-Object {$_. Identifikácia -eq 1796})
            $event 1796Count = $event 1796Array.Count
            if ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object TimeCreated -Descending | Select-Object – prvá 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 "Udalosť 1796 (zaznamenané chyby) Počet: $event 1796Count" $(if ($event 1796ErrorCode) { "Code: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 - Vyžaduje sa reštart (NOT chyba - aktualizácia bude pokračovať po reštarte)
            $event 1800Array = @($events | Where-Object {$_. Identifikácia -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            ak ($rebootPending) {
                Write-Host "Udalosť 1800 (Čaká sa na reštart): Aktualizácia bude pokračovať po reštarte" -ForegroundColor Cyan
            }
            
            # 24. Event1802 - Známy problém firmvéru (zaznamenať KI_<číslo> z SkipReason)
            $event 1802Array = @($events | Where-Object {$_. Identifikácia -eq 1802})
            $event 1802Count = $event 1802Array.Count
            if ($event 1802Count -gt 0) {
                $latestEvent 1802 = $event 1802Array | Sort-Object TimeCreated -Descending | Select-Object – prvá 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Event 1802 (Known Firmware Issue) Count: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 – chýbajúca aktualizácia KEK (OEM potrebuje dodať KEK podpísaný PK)
            $event 1803Array = @($events | Where-Object {$_. Identifikácia -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            ak ($missingKEK) {
                Write-Host "Udalosť 1803 (chýba KEK): OEM musí dodávať PK podpísaný KEK" -ForegroundColor Yellow
            }
        } else {
            Write-Host "Aktualizácia dokončená (udalosť 1808 alebo stav=aktualizované) - vynechanie analýzy chýb" -Farba popredia zelená
        }
    }
} chytiť {
    Write-Warning "Chyba pri načítavaní denníkov udalostí. Môže vyžadovať oprávnenia správcu: $_"
    $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 "Identifikácia poslednej udalosti: chyba"
    Write-Host "Bucket ID: Error"
    Write-Host "Spoľahlivosť: Chyba"
    Write-Host "Event 1801 Count: 0"
    Write-Host "Udalosť 1808 Počet: 0"
}

# Dotazy WMI/CIM (5 hodnôt)

# 26. Verzia OS
# PS Verzia: 3.0 + (použite Get-WmiObject pre 2.0) | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nepodarilo sa načítať verziu operačného systému"
        $osVersion = "Neznáme"
    } else {
        $osVersion = $osInfo.Version
    }
    Write-Host Verzia operačného systému: $osVersion
} chytiť {
    # CIM môže zlyhať v niektorých prostrediach - použite záložné
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([reťazec]::IsNullOrEmpty($osVersion)) { $osVersion = "Neznáme" }
    Write-Host Verzia operačného systému: $osVersion
}

# 27. Čas posledného spustenia
# PS Verzia: 3.0 + (použite Get-WmiObject pre 2.0) | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nepodarilo sa načítať čas posledného spustenia"
        $lastBootTime = $null
        Write-Host "Čas posledného spustenia: Nie je k dispozícii"
    } else {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Čas posledného spustenia: $lastBootTime"
    }
} chytiť {
    # CIM môže zlyhať v niektorých prostrediach - použite záložné
    vyskúšať {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Čas začatia
    } chytiť {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Last Boot Time: $lastBootTime" } else { Write-Host "Last Boot Time: Not Available" }
}

# 28. BaseBoardManufacturer
# PS Verzia: 3.0 + (použite Get-WmiObject pre 2.0) | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Nepodarilo sa načítať výrobcu základnej dosky"
        $baseBoardManufacturer = "Neznáme"
    } else {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Výrobca základnej dosky: $baseBoardManufacturer"
} chytiť {
    # CIM môže zlyhať - základné informácie o tabuli sú doplnkové
    $baseBoardManufacturer = "Neznáme"
    Write-Host "Výrobca základnej dosky: $baseBoardManufacturer"
}

# 29. Základný dolnýprodukt
# PS Verzia: 3.0 + (použite Get-WmiObject pre 2.0) | Spravovanie: Nie | Systémové požiadavky: Žiadne
vyskúšať {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Produkt základnej dosky sa nepodarilo načítať"
        $baseBoardProduct = Neznáme
    } else {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Baseboard Product: $baseBoardProduct"
} chytiť {
    # CIM môže zlyhať - základné informácie o tabuli sú doplnkové
    $baseBoardProduct = Neznáme
    Write-Host "Baseboard Product: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS Verzia: Všetky | Spravovanie: Nie | Systémové požiadavky: Naplánovaná úloha existuje
# Skontroluje, či je povolená
naplánovaná úloha secure-boot-update $secureBootTaskEnabled = $null
$secureBootTaskStatus = "Neznáme"
vyskúšať {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    if ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | Konvertovať Z-Csv
        ak ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Ready' -or $taskData.Status -eq 'Running')
        }
    } else {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "Úloha aktualizácie SecureBoot: $secureBootTaskStatus (povolené: $secureBootTaskEnabled)" -Farba popredia žltá
    } else {
        Write-Host "Úloha aktualizácie SecureBoot: $secureBootTaskStatus (povolené: $secureBootTaskEnabled)" -Farba popredia zelená
    }
} chytiť {
    $secureBootTaskStatus = "Chyba"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. Stav kľúča WinCS (F33E0C8E002 – aktualizácia certifikátu zabezpečeného spustenia)
# PS Verzia: Všetky | Spravovanie: Áno (pre dotaz) | Systémové požiadavky: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = Neznáme
vyskúšať {
    # Skontrolujte bežné umiestnenia pre 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 }
    }

    ak ($wincsFlagsPath) {
        # Kľúč špecifický pre dotaz – vyžaduje práva
správcu         $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Skontrolujte, či je použitý kľúč (vyhľadajte výraz Aktívna konfigurácia alebo podobný indikátor)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Použité"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            } elseif ($queryOutputStr -match "nenašiel sa|Žiadna konfigurácia") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = NotApplied
                Write-Host "WinCS Key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } else {
                # Kľúč existuje – skontrolujte výstup stavu
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Použité"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            }
        } else {
            # Skontrolujte konkrétne chybové hlásenia
            if ($queryOutputStr -match "Access denied|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS Key F33E0C8E002: Access denied (run as admin)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "nenašiel sa|Žiadna konfigurácia") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = NotApplied
                Write-Host "WinCS Key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } else {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "WinCS Key F33E0C8E002: Query failed" -ForegroundColor Red
            }
        }
    } else {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS Key F33E0C8E002: WinCsFlags.exe not found" -ForegroundColor Gray
    }
} chytiť {
    $wincsKeyStatus = "Chyba"
    Write-Host "WinCS Key F33E0C8E002: Kontrola chýb - $_" -ForegroundColor Red
}              

# =============================================================================
# Remediation Detection - Status Output & Exit Code
# =============================================================================

# Vytvoriť objekt stavu zo všetkých zhromaždených údajov
inventára $status = [ordered]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Chyba = $uefica 2023Chyba
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = if ($null -ne $availableUpdates) { $availableUpdatesHex } else { $null }
    AvailableUpdatesPolicy = if ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } else { $null }
    Názov hostiteľa = $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
    Spoľahlivosť = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<číslo> z udalosti
SkipReason in BucketId     Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Chybové udalosti so zachytenými podrobnosťami
    Event1795Count = $event 1795Count # Firmware vrátil chybu
    Event1795ErrorCode = $event 1795ErrorCode # Kód chyby z firmvéru
    Event1796Count = $event 1796Count # Kód chyby sa zapísal do denníka
    Event1796ErrorCode = $event 1796ErrorCode # Captured error code
    Event1800Count = $event 1800Count # Vyžaduje sa reštart (NOT chyba)
    Čaká sa na reštart = $rebootPending # True, ak je prítomná
udalosť 1800     Event1802Count = $event 1802Count # Známy problém
s firmvérom     KnownIssueId = $knownIssueId # KI_<číslo> z SkipReason
    Event1803Count = $event 1803Count # Chýba aktualizácia
KEK     MissingKEK = $missingKEK # OEM potrebuje dodávať PK podpísané KEK
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True, ak sa použije
kľúč F33E0C8E002     WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound atď.
}

# Výstup stavu – pre agregáciu
údajov $jsonOutput = $status | ConvertTo-Json -Komprimovať

# Ak je zadaný OutputPath, uložte ho do súboru; v opačnom prípade výstup na stdout
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Overiť OutputPath - preskočiť, ak to vyzerá ako žiadosť o pomoc, alebo má neplatné znaky
    if ($OutputPath -match '^[/\-]' -alebo $OutputPath -match '[<>:"|? *]') {
        Write-Host "Invalid OutputPath specified, outputting to stdout" -ForegroundColor Yellow
       
Write-Output $jsonOutput         if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") { exit 0 } else { exit 1 }
    }
    
    # Skontrolujte, či výstupný priečinok existuje
    if (-not (Test-Path $OutputPath)) {
        vyskúšať {
            New-Item -ItemType Directory -Path $OutputPath -Force | Hodnota out-null
        } chytiť {
            Write-Warning "Nepodarilo sa vytvoriť výstupný priečinok: $OutputPath - $_"
        }
    }
    
    # Uložiť do HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    vyskúšať {
        $jsonOutput | Out-File -FilePath $outputFile -kódovanie UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } chytiť {
        Write-Warning "Nedá sa zapisovať do súboru: $outputFile - $_"
        # Vráťte sa do úzadenia
       
Write-Output $jsonOutput     }
} else {
    # Pôvodné správanie – výstup do úložiska
   
Write-Output $jsonOutput }

# Ukončiť kód: "Aktualizované" je hodnota úspechu na scenár
if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") {
    exit 0 # Without issue
} else {
    exit 1 # With issue
}