Ukázkový skript pro shromažďování dat inventáře zabezpečeného spouštění

<#
. SYNOPSE
    Zjistí stav aktualizace certifikátu zabezpečeného spouštění pro monitorování v rámci celého vozového parku.

. POPIS
    Tento detekční skript shromažďuje stav zabezpečeného spouštění, hodnoty registru aktualizace certifikátu.
    a informace o zařízení. Výstupem je řetězec JSON pro monitorování a vytváření sestav.

    Kompatibilní s Intune nápravami, kolekcemi založenými na objektech zásad zásad a dalšími nástroji pro správu.
Není potřeba žádný skript pro nápravu – jedná se pouze o monitorování.

    Exit 0 = "Without issue" (certifikáty aktualizovány)
    Exit 1 = "With issue" (certifikáty nejsou aktualizované – pouze informační)

. PARAMETER OutputPath
    Volitelné. Cesta ke složce, do které se uloží soubor JSON.
Pokud je tato možnost k dispozici, uloží HOSTNAME_latest.json do této složky.
Pokud není k dispozici, vypíše json do stdout (původní chování).

. PŘÍKLAD
    # Output to stdout (Intune/SCCM detection)
    .\Detect-SecureBootCertUpdateStatus.ps1

. PŘÍKLAD
    # Uložit do sdílené síťové složky (nasazení objektu zásad zabezpečení)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. POZNÁMKY
    Cesty registru na https://aka.ms/securebootplaybook:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    SOFTWARE JE POSKYTOVÁN "TAK, JAK JE", BEZ ZÁRUKY JAKÉHOKOLI DRUHU, EXPRESNÍ NEBO
    PŘEDPOKLÁDANÉ, MIMO JINÉ VČETNĚ ZÁRUK PRODEJNOSTI,
    ZPŮSOBILOST K URČITÉMU ÚČELU A NEPORUŠENÍ PRÁV. V ŽÁDNÉM PŘÍPADĚ NEBUDE
    AUTOŘI NEBO DRŽITELÉ AUTORSKÝCH PRÁV JSOU ZODPOVĚDNÍ ZA JAKÉKOLI NÁROKY, ŠKODY NEBO JINÉ
    ODPOVĚDNOST, AŤ UŽ V RÁMCI SMLUVNÍHO JEDNÁNÍ, OBČANSKOPRÁVNÍHO NEBO JINÉHO JEDNÁNÍ, VYPLÝVAJÍCÍ Z
    MIMO SOFTWARE NEBO V SOUVISLOSTI S JEHO POUŽÍVÁNÍM NEBO JINÝM JEDNÁNÍM V RÁMCI
    SOFTWARE.
#>
param(
    [Parameter(Mandatory = $false)]
    [řetězec]$OutputPath
)

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples"
# Poznámka: Tento skript běží na koncových bodech a shromažďuje data o stavu zabezpečeného spouštění.

# 1. Hostname
# PS Verze: Vše | Správa: Ne | Požadavky na systém: Žádné
try {
    $hostname = $env:NÁZEVPOČÍTAČE
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Název hostitele nelze určit"
        $hostname = "Neznámé"
    }
    Write-Host Název hostitele: $hostname
} catch {
    Write-Warning "Chyba při načítání názvu hostitele: $_"
    $hostname = "Chyba"
    Write-Host Název hostitele: $hostname
}

# 2.
Čas kolekce # PS Verze: Vše | Správa: Ne | Požadavky na systém: Žádné
try {
    $collectionTime = Získat datum
    if ($null -eq $collectionTime) {
        Write-Warning Nelze načíst aktuální datum a čas.
        $collectionTime = "Neznámý"
    }
    Write-Host "Čas shromažďování: $collectionTime"
} catch {
    Write-Warning "Chyba při načítání data a času: $_"
    $collectionTime = "Chyba"
    Write-Host "Čas shromažďování: $collectionTime"
}

# Registry: Secure Boot Main Key (3 hodnoty)

# 3. SecureBootEnabled
# PS Verze: 3.0+ | Správa: Může se vyžadovat | Požadavky na systém: Systém s podporou rozhraní UEFI nebo zabezpečeného
spouštění try {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Zabezpečené spouštění povoleno: $secureBootEnabled"
} catch {
    Write-Warning Nejde určit stav zabezpečeného spouštění pomocí rutiny: $_"
    # Zkuste záložní
registr     try {
        $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Zabezpečené spouštění povoleno: $secureBootEnabled"
    } catch {
        Write-Warning Nejde určit stav zabezpečeného spouštění prostřednictvím registru. Systém nemusí podporovat UEFI nebo zabezpečené spouštění."
        $secureBootEnabled = $null
        Write-Host "Zabezpečené spouštění povoleno: není k dispozici"
    }
}

# 4. HighConfidenceOptOut
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "High Confidence Opt Out: $highConfidenceOptOut"
} catch {
    # HighConfidenceOptOut je nepovinný – není k dispozici ve většině systémů
.     $highConfidenceOptOut = $null
    Write-Host "High Confidence Opt out: Not Set"
}

# 4b. MicrosoftUpdateManagedOptIn
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed Opt In: $microsoftUpdateManagedOptIn"
} catch {
    # MicrosoftUpdateManagedOptIn je nepovinný – není k dispozici ve většině systémů
.     $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed Opt In: Not Set"
}

# 5. AvailableUpdates
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Převést do šestnáctkového formátu
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "K dispozici Aktualizace: $availableUpdatesHex"
    } else {
        Write-Host "K dispozici Aktualizace: Není k dispozici"
    }
} catch {
    Write-Warning "Klíč registru AvailableUpdates nebyl nalezen nebo je nepřístupný"
    $availableUpdates = $null
    Write-Host "K dispozici Aktualizace: Není k dispozici"
}

# 5b. AvailableUpdatesPolicy (trvalá hodnota řízená objektem zásad zabezpečení)
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Převést do šestnáctkového formátu
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Dostupné zásady Aktualizace: $availableUpdatesPolicyHex"
    } else {
        Write-Host "Dostupné zásady Aktualizace: Nenastaví se"
    }
} catch {
    # AvailableUpdatesPolicy je nepovinný – nastaví se jenom při použití objektu zásad skupiny
.     $availableUpdatesPolicy = $null
    Write-Host "Dostupné zásady Aktualizace: Nenastavěné"
}

# Registr: Servisní klíč (3 hodnoty)

# 6. UEFICA2023Status
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $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"
} catch {
    Write-Warning "Windows UEFI CA 2023 Status registry key not found or inaccessible" (Klíč registru stavu rozhraní UEFI systému Windows 2023 nebyl nalezen nebo je nepřístupný)
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 Status: Not available"
}

# 7. Chyba UEFICA2023
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "Chyba ca UEFI 2023: $uefica 2023Error"
} catch {
    # UEFICA2023Chyba existuje pouze v případě, že došlo k chybě – absence je dobrá
.     $uefica 2023Error = $null
    Write-Host "UEFI CA 2023 Error: None"
}

# 8. UEFICA2023ErrorEvent
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "Událost chyby UEFI CA 2023: $uefica 2023ErrorEvent"
} catch {
    $uefica 2023ErrorEvent = $null
    Write-Host "Událost chyby UEFI CA 2023: Není k dispozici"
}

# Registry: Atributy zařízení (7 hodnot: 9-15)

# 9. OEMManufacturerName
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $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 je prázdný"
        $oemManufacturerName = "Neznámý"
    }
    Write-Host "OEM Manufacturer Name: $oemManufacturerName"
} catch {
    Write-Warning klíč registru OEMManufacturerName nebyl nalezen nebo je nepřístupný.
    $oemManufacturerName = $null
    Write-Host "Název výrobce OEM: Není k dispozici"
}

# 10. OEMModelSystemFamily
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([string]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily je prázdný"
        $oemModelSystemFamily = "Neznámý"
    }
    Write-Host "OEM Model System Family: $oemModelSystemFamily"
} catch {
    Write-Warning klíč registru OEMModelSystemFamily nebyl nalezen nebo je nepřístupný.
    $oemModelSystemFamily = $null
    Write-Host "Řada systémů modelů OEM: Není k dispozici"
}

# 11. OEMModelNumber
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([string]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber je prázdné".
        $oemModelNumber = "Neznámé"
    }
    Write-Host "Číslo modelu OEM: $oemModelNumber"
} catch {
    Write-Warning klíč registru OEMModelNumber nebyl nalezen nebo je nepřístupný.
    $oemModelNumber = $null
    Write-Host "Číslo modelu OEM: Není k dispozici"
}

# 12. FirmwareVersion
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([string]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning FirmwareVersion je prázdná
.         $firmwareVersion = "Neznámé"
    }
    Write-Host "Verze firmwaru: $firmwareVersion"
} catch {
    Write-Warning "Klíč registru FirmwareVersion nebyl nalezen nebo je nepřístupný"
    $firmwareVersion = $null
    Write-Host "Verze firmwaru: není k dispozici"
}

# 13. FirmwareReleaseDate
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([string]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning FirmwareReleaseDate je prázdný.
        $firmwareReleaseDate = "Neznámý"
    }
    Write-Host "Datum vydání firmwaru: $firmwareReleaseDate"
} catch {
    Write-Warning Klíč registru FirmwareReleaseDate nebyl nalezen nebo je nepřístupný.
    $firmwareReleaseDate = $null
    Write-Host "Datum vydání firmwaru: Není k dispozici"
}

# 14. OSArchitecture
# PS Verze: Vše | Správa: Ne | Požadavky na systém: Žádné
try {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Zkuste záložní
registr         $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture nelze určit"
        $osArchitecture = "Neznámé"
    }
    Write-Host "Architektura operačního systému: $osArchitecture"
} catch {
    Write-Warning "Chyba při načítání OSArchitecture: $_"
    $osArchitecture = "Neznámý"
    Write-Host "Architektura operačního systému: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS Verze: Vše | Správa: Může se vyžadovat | Požadavky na systém: Žádné
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Convert FILETIME to UTC DateTime — registr ukládá jako REG_BINARY (byte[]) nebo REG_QWORD (long)
    if ($null -ne $canAttemptUpdateAfter) {
        try {
            if ($canAttemptUpdateAfter -is [byte[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter; 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } catch {
            Write-Warning "Nelze převést CanAttemptUpdateAfter FILETIME na DateTime"
        }
    }
    Write-Host "Může se pokusit o aktualizaci po: $canAttemptUpdateAfter"
} catch {
    Write-Warning "CanAttemptUpdateAfter klíč registru nebyl nalezen nebo je nepřístupný"
    $canAttemptUpdateAfter = $null
    Write-Host "Může se pokusit o aktualizaci po: Není k dispozici"
}

# Protokoly událostí: Systémový protokol (10 hodnot: 16-25)

# 16-25. Dotazy na protokol událostí
# ID událostí:
# 1801 - Aktualizace byla zahájena, vyžaduje
se restartování # 1808 - Aktualizace byla úspěšně dokončena
# 1795 - Firmware vrátil chybu (kód chyby zachycení)
# 1796 - Chyba protokolovaná s kódem chyby (kód zachycení)
# 1800 - Je potřeba restartovat (NE chyba - aktualizace bude pokračovat po restartování)
# 1802 - Známý problém s firmwarem blokovaná aktualizace (zachytávání KI_<číslo> z SkipReason)
# 1803 - Odpovídající aktualizace KEK nebyla nalezena (výrobce OEM musí dodat KEK podepsaný pk)
# PS Verze: 3.0+ | Správa: Může být vyžadováno pro systémový protokol | Požadavky na systém: Žádné
try {
    # Dotazování všech relevantních ID
událostí zabezpečeného spouštění     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    if ($events. Počet -eq 0) {
        Write-Warning "V systémovém protokolu nebyly nalezeny žádné události zabezpečeného spouštění"
        $latestEventId = $null
        $bucketId = $null
        $confidence = $null
        $skipReasonKnownIssue = $null
        $event 1801Počet = 0
        $event 1808Počet = 0
        $event 1795Počet = 0
        $event 1795ErrorCode = $null
        $event 1796Počet = 0
        $event 1796ErrorCode = $null
        $event 1800Počet = 0
        $rebootPending = $false
        $event 1802Počet = 0
        $knownIssueId = $null
        $event 1803Počet = 0
        $missingKEK = $false
        Write-Host "Nejnovější ID události: Není k dispozici"
        Write-Host "Id kbelíku: Není k dispozici"
        Write-Host "Spolehlivost: Není k dispozici"
        Write-Host "Událost 1801 Count: 0"
        Write-Host "Událost 1808 Count: 0"
    } else {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated -Descending | Select-Object -První 1
        if ($null -eq $latestEvent) {
            Write-Warning Nejde určit nejnovější událost.
            $latestEventId = $null
            Write-Host "Nejnovější ID události: Není k dispozici"
        } else {
            $latestEventId = $latestEvent.Id
            Write-Host "Nejnovější ID události: $latestEventId"
        }

        # 17. BucketID – extrahované z události 1801/1808
        if ($null -ne $latestEvent -a $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)) {
                $bucketId = $matches[1]. Trim()
                Write-Host ID kbelíku: $bucketId
            } else {
                Write-Warning BucketId se ve zprávě události nenašlo.
                $bucketId = $null
                Write-Host "ID kbelíku: v události se nenašlo"
            }
        } else {
            Write-Warning "Nejnovější událost nebo zpráva má hodnotu null, nelze extrahovat BucketId"
            $bucketId = $null
            Write-Host "Id kbelíku: Není k dispozici"
        }

        # 18. Spolehlivost – extrahovaná z události 1801/1808
        if ($null -ne $latestEvent -a $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)' {
                $confidence = $matches[1]. Trim()
                Write-Host "Spolehlivost: $confidence"
            } else {
                Write-Warning "Ve zprávě události nebyla nalezena úroveň spolehlivosti"
                $confidence = $null
                Write-Host "Spolehlivost: Nenalezena v události"
            }
        } else {
            Write-Warning "Nejnovější událost nebo zpráva má hodnotu null, nelze extrahovat spolehlivost"
            $confidence = $null
            Write-Host "Spolehlivost: Není k dispozici"
        }

        # 18b. SkipReason – extrahuje KI_<číslo> ze SkipReason ve stejné události jako BucketId
.         # Zachycuje ID známých problémů, která se zobrazují vedle BucketId/Confidence (nejen události 1802).
        $skipReasonKnownIssue = $null
        if ($null -ne $latestEvent -a $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'SkipReason:\s*(KI_\d+)') {
                $skipReasonKnownIssue = $matches[1]
                Write-Host "SkipReason – známý problém: $skipReasonKnownIssue" -ForegroundColor Yellow
            }
        }

        # 19. Událost1801Count
        $event 1801Array = @($events | Where-Object {$_. ID -eq 1801})
        $event 1801Count = $event 1801Array.Count
        Write-Host "Událost 1801 Count: $event 1801Count"

        # 20. Událost1808Count
        $event 1808Array = @($events | Where-Object {$_. ID -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Událost 1808 Count: $event 1808Count"
        
        # Inicializace proměnných chybových událostí
        $event 1795Počet = 0
        $event 1795ErrorCode = $null
        $event 1796Počet = 0
        $event 1796ErrorCode = $null
        $event 1800Počet = 0
        $rebootPending = $false
        $event 1802Počet = 0
        $knownIssueId = $null
        $event 1803Počet = 0
        $missingKEK = $false
        
        # Zkontrolujte chybové události pouze v případě, že aktualizace NENÍ dokončená
.         # Přeskočit analýzu chyb, pokud: 1808 je nejnovější událost NEBO UEFICA2023Status je "Aktualizováno"
        $updateComplete = ($latestEventId -eq 1808) -nebo ($uefica 2023Status -eq "Aktualizováno")
        
        if (-not $updateComplete) {
            Write-Host "Aktualizace není dokončená – kontrola chybových událostí..." -ForegroundColor Yellow
            
            # 21. Událost1795 – chyba firmwaru (zachytávání kódu chyby)
            $event 1795Array = @($events | Where-Object {$_. ID -eq 1795})
            $event 1795Count = $event 1795Array.Count
            if ($event 1795Count -gt 0) {
                $latestEvent 1795 = $event 1795Array | Sort-Object TimeCreated -Descending | Select-Object -První 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 "Událost 1795 (chyba firmwaru): $event 1795Count" $(if ($event 1795ErrorCode) { "Code: $event 1795ErrorCode" })
            }
            
            # 22. Událost1796 – zaprotokolovaný kód chyby (kód chyby zachytávání)
            $event 1796Array = @($events | Where-Object {$_. ID -eq 1796})
            $event 1796Count = $event 1796Array.Count
            if ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object TimeCreated -Descending | Select-Object -První 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 "Událost 1796 (zaprotokolovaná chyba): $event 1796Count" $(if ($event 1796ErrorCode) { "Code: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 – vyžaduje se restartování (NE chyba – po restartování bude pokračovat aktualizace)
            $event 1800Array = @($events | Where-Object {$_. ID -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Počet -gt 0
            if ($rebootPending) {
                Write-Host "Událost 1800 (čeká na restartování): Aktualizace bude pokračovat po restartování" -ForegroundColor azurová
            }
            
            # 24. Událost 1802 – známý problém s firmwarem (zachycení čísla KI_<> z SkipReason)
            $event 1802Array = @($events | Where-Object {$_. ID -eq 1802})
            $event 1802Count = $event 1802Array.Count
            if ($event 1802Count -gt 0) {
                $latestEvent 1802 = $event 1802Array | Sort-Object TimeCreated -Descending | Select-Object -První 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Událost 1802 (známý problém s firmwarem): počet $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Událost 1803 – Chybějící aktualizace KEK (výrobce OEM musí dodat klíč KEK podepsaný pk)
            $event 1803Array = @($events | Where-Object {$_. ID -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Počet -gt 0
            if ($missingKEK) {
                Write-Host "Událost 1803 (chybějící klíč KEK): Výrobce OEM musí dodat klíč KEK podepsaný pk" –ForegroundColor Yellow
            }
        } else {
            Write-Host "Update complete (Event 1808 or Status=Updated) - skiping error analysis" -ForegroundColor Green
        }
    }
} catch {
    Write-Warning "Při načítání protokolů událostí došlo k chybě. Může vyžadovat oprávnění správce: $_"
    $latestEventId = $null
    $bucketId = $null
    $confidence = $null
    $skipReasonKnownIssue = $null
    $event 1801Počet = 0
    $event 1808Počet = 0
    $event 1795Počet = 0
    $event 1795ErrorCode = $null
    $event 1796Počet = 0
    $event 1796ErrorCode = $null
    $event 1800Počet = 0
    $rebootPending = $false
    $event 1802Počet = 0
    $knownIssueId = $null
    $event 1803Počet = 0
    $missingKEK = $false
    Write-Host Nejnovější ID události: Chyba
    Write-Host ID kbelíku: Chyba
    Write-Host "Spolehlivost: Chyba"
    Write-Host "Událost 1801 Count: 0"
    Write-Host "Událost 1808 Count: 0"
}

# Dotazy WMI/CIM (5 hodnot)

# 26. OSVersion
# PS Verze: 3.0+ (použijte Get-WmiObject pro verzi 2.0) | Správa: Ne | Požadavky na systém: Žádné
try {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -nebo [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nepovedlo se načíst verzi operačního systému"
        $osVersion = "Neznámý"
    } else {
        $osVersion = $osInfo.Version
    }
    Write-Host "Verze operačního systému: $osVersion"
} catch {
    # CIM může v některých prostředích selhat – použijte náhradní
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "Verze operačního systému: $osVersion"
}

# 27. LastBootTime
# PS Verze: 3.0+ (použijte Get-WmiObject pro verzi 2.0) | Správa: Ne | Požadavky na systém: Žádné
try {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -nebo $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nepodařilo se načíst čas posledního spuštění"
        $lastBootTime = $null
        Write-Host "Čas posledního spuštění: Není k dispozici"
    } else {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Čas posledního spuštění: $lastBootTime"
    }
} catch {
    # CIM může v některých prostředích selhat – použijte náhradní
    try {
        $lastBootTime = (Get-Process -ID 0 -ErrorAction SilentlyContinue). Starttime
    } catch {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Last Boot Time: $lastBootTime" } else { Write-Host "Last Boot Time: Not available" }
}

# 28. BaseBoardManufacturer
# PS Verze: 3.0+ (použijte Get-WmiObject pro verzi 2.0) | Správa: Ne | Požadavky na systém: Žádné
try {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -nebo [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning Nelze načíst výrobce základní desky.
        $baseBoardManufacturer = "Neznámý"
    } else {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Výrobce základní desky: $baseBoardManufacturer"
} catch {
    # CIM může selhat - informace o základní desce jsou doplňkové
    $baseBoardManufacturer = "Neznámý"
    Write-Host "Výrobce základní desky: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS Verze: 3.0+ (použijte Get-WmiObject pro verzi 2.0) | Správa: Ne | Požadavky na systém: Žádné
try {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -nebo [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nepodařilo se načíst produkt základní desky"
        $baseBoardProduct = "Neznámý"
    } else {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Základní deska: $baseBoardProduct"
} catch {
    # CIM může selhat - informace o základní desce jsou doplňkové
    $baseBoardProduct = "Neznámý"
    Write-Host "Základní deska: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS Verze: Vše | Správa: Ne | Požadavky na systém: Naplánovaná úloha existuje
# Zkontroluje, jestli je povolená
naplánovaná úloha zabezpečeného spouštění a aktualizace. $secureBootTaskEnabled = $null
$secureBootTaskStatus = "Neznámý"
try {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    if ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | ConvertFrom-Csv
        if ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Ready' -nebo $taskData.Status -eq 'Running')
        }
    } else {
        $secureBootTaskStatus = Nenalezeno
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "Úloha aktualizace SecureBoot: $secureBootTaskStatus (povoleno: $secureBootTaskEnabled)" -ForegroundColor Yellow
    } else {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -ForegroundColor Green
    }
} catch {
    $secureBootTaskStatus = "Chyba"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. Stav klíče WinCS (F33E0C8E002 – aktualizace certifikátu zabezpečeného spouštění)
# PS Verze: Vše | Správa: Ano (pro dotaz) | Požadavky na systém: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Neznámý"
try {
    # Zkontrolujte běžná umístění pro WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p v $possiblePaths) {
        if (test-path $p) { $wincsFlagsPath = $p; break }
    }

    if ($wincsFlagsPath) {
        # Klíč specifický pro dotaz – vyžaduje práva
správce.         $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Zkontrolujte, jestli je použit klíč (vyhledejte aktivní konfiguraci nebo podobný indikátor).
            if ($queryOutputStr -match "Aktivní konfigurace.*:.*enabled" -nebo $queryOutputStr -match "Konfigurace.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Použito"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            } elseif ($queryOutputStr -match "nenalezena|Žádná konfigurace") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS Key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } else {
                # Klíč existuje – zkontrolujte stav
ve výstupu.                 $wincsKeyApplied = $true
                $wincsKeyStatus = "Použito"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            }
        } else {
            # Kontrola konkrétních chybových zpráv
            if ($queryOutputStr -match "Přístup odepřen|správce") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS Key F33E0C8E002: Přístup odepřen (spustit jako správce)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "nenalezena|Žádná konfigurace") {
                $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
    }
} catch {
    $wincsKeyStatus = "Chyba"
    Write-Host "WinCS Key F33E0C8E002: Kontrola chyb – $_" -ForegroundColor Red
}              

# =============================================================================
# Detekce nápravy – stavový výstup & ukončovací kód
# =============================================================================

# Stavový objekt sestavení ze všech shromážděných dat
inventáře $status = [objednaný]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Error = $uefica 2023Error
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = if ($null -ne $availableUpdates) { $availableUpdatesHex } else { $null }
    AvailableUpdatesPolicy = if ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } else { $null }
    Název hostitele = $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
    Confidence = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<číslo> z události
SkipReason v BucketId     Událost1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Chybové události se zachycenými podrobnostmi
    Event1795Count = $event 1795Count # Chyba
vrácená firmwarem     Event1795ErrorCode = $event 1795ErrorCode # Kód chyby z firmwaru
    Event1796Count = $event 1796Count # Zaprotokolovaný
kód chyby     Event1796ErrorCode = $event 1796ErrorCode # Zachycený kód
chyby     Event1800Count = $event 1800Count # Vyžaduje se restartování (NOT chyba)
    RebootPending = $rebootPending # True, pokud je k dispozici
událost 1800     Event1802Count = $event 1802Count # Známý problém s firmwarem
    KnownIssueId = $knownIssueId # KI_<číslo> z SkipReason
    Event1803Count = $event 1803Count # Chybějící aktualizace
KEK     MissingKEK = $missingKEK # OEM potřebuje dodat klíč KEK
podepsaný pk     OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True, pokud je použit
klíč F33E0C8E002     WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound atd.
}

# Výstup stavu - Pro agregaci
dat $jsonOutput = $status | ConvertTo-Json -Compress

# Pokud OutputPath, uložit do souboru; jinak výstup do stdoutu
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Validate OutputPath – pokud vypadá jako žádost o pomoc nebo má neplatné znaky
, přeskočte.     if ($OutputPath -match '^[/\-]' -nebo $OutputPath -match '[<>:"|? *]') {
        Write-Host "Zadána neplatná cesta výstupu, výstup do stdout" -ForegroundColor Yellow
       
Write-Output $jsonOutput         if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") { exit 0 } else { exit 1 }
    }
    
    # Ujistěte se, že výstupní složka existuje
.     if (-not (test-path $OutputPath)) {
        try {
            New-Item -ItemType Directory -Path $OutputPath -Force | Out-Null
        } catch {
            Write-Warning "Nelze vytvořit výstupní složku: $OutputPath – $_"
        }
    }
    
    # Uložit do HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    try {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } catch {
        Write-Warning "Nelze zapisovat do souboru: $outputFile - $_"
        # Fall back to stdout
       
Write-Output $jsonOutput     }
} else {
    # Původní chování - výstup do stdout
   
Write-Output $jsonOutput }

# Ukončovací kód: "Aktualizováno" je hodnota úspěchu podle playbooku
. if ($secureBootEnabled -a $uefica 2023Status -eq "Updated") {
    exit 0 # Bez problému
} else {
    exit 1 # With issue
}