Ogledna skripta za prikupljanje podataka inventara sigurnog pokretanja sustava

<#
. SINOPSIS
    Otkriva status ažuriranja certifikata sigurnog pokretanja radi nadzora na razini cijele flote.

. OPIS
    Ova skripta otkrivanja prikuplja vrijednosti registra sigurnog pokretanja sustava, ažuriranja certifikata,
    i podatke o uređaju. Izlaz je JSON niz za praćenje i izvješćivanje.

    Kompatibilan s popravcima servisa Intune, zbirkom temeljenom na GPO-u i drugim alatima za upravljanje.
Nije potrebna skripta za popravak – ovo je samo nadzor.

    Izlaz 0 = "Bez problema" (ažurirani certifikati)
    Izlaz 1 = "S izdavanjem" (certifikati nisu ažurirani – samo informativni sadržaji)

. PARAMETAR: OutputPath
    Neobavezno. Put do mape u koju će se JSON datoteka spremiti.
Ako se HOSTNAME_latest.json navede, sprema u tu mapu.
Ako nije naveden, JSON šalje na stdout (izvorno ponašanje).

. PRIMJER
    # Izlaz na stdout (otkrivanje Intune/SCCM)
    .\Detect-SecureBootCertUpdateStatus.ps1

. PRIMJER
    # Spremanje u zajednički mrežni resurs (implementacija GPO-a)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. NAPOMENE
    Putovi registra po 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
    PODRAZUMIJEVA, UKLJUČUJUĆI, ALI NE OGRANIČAVAJUĆI SE NA JAMSTVA UTRŽIVOSTI,
    PRIKLADNOST ZA POSEBNU SVRHU I NEPOVREDIVOST. NI
U KOJEM SLUČAJU     AUTORI ILI NOSITELJI AUTORSKIH PRAVA ODGOVORNI SU ZA SVE ZAHTJEVE, ŠTETE ILI DRUGE
    ODGOVORNOSTI, BILO U SKLOPU UGOVORA, PREKRŠAJA ILI NA NEKI DRUGI NAČIN, KOJA PROIZLAZI IZ,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTVER.
#>
param(
    [Parameter(Mandatory = $false)]
    [niz]$OutputPath
)

# URL preuzimanja: https://aka.ms/getsecureboot -> "Deployment and monitoring samples"
# Napomena: ta se skripta izvršava na krajnjim točkama radi prikupljanja podataka o statusu sigurnog pokretanja sustava.

# 1. Naziv
glavnog računala # Verzija PS-a: Sve | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $hostname = $env:COMPUTERNAME
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Naziv glavnog računala nije moguće odrediti"
        $hostname = "Nepoznato"
    }
    Write-Host "Hostname: $hostname"
} catch {
    Write-Warning "Pogreška pri dohvaćanju naziva glavnog računala: $_"
    $hostname = "Pogreška"
    Write-Host "Hostname: $hostname"
}

# 2. Vrijeme
prikupljanja # Verzija PS-a: Sve | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $collectionTime = Get-Date
    if ($null -eq $collectionTime) {
        Write-Warning "Nije moguće dohvatiti trenutačni datum/vrijeme"
        $collectionTime = "Nepoznato"
    }
    Write-Host "Vrijeme prikupljanja: $collectionTime"
} catch {
    Write-Warning "Pogreška prilikom dohvaćanja datuma/vremena: $_"
    $collectionTime = "Pogreška"
    Write-Host "Vrijeme prikupljanja: $collectionTime"
}

# Registar: glavni ključ sigurnog pokretanja sustava (3 vrijednosti)

# 3. SecureBootEnabled
# Verzija PS-a: 3.0+ | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Sustav
koji podržava UEFI/sigurno pokretanje sustava try {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Omogućeno je sigurno pokretanje: $secureBootEnabled"
} catch {
    Write-Warning "Nije moguće utvrditi status sigurnog pokretanja putem cmdleta: $_"
    # Isprobajte rezervu registra
    try {
        $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Omogućeno je sigurno pokretanje: $secureBootEnabled"
    } catch {
        Write-Warning "Nije moguće utvrditi status sigurnog pokretanja putem registra. Sustav možda ne podržava UEFI/sigurno pokretanje."
        $secureBootEnabled = $null
        Write-Host "Omogućeno je sigurno pokretanje: nije dostupno"
    }
}

# 4. HighConfidenceOptOut
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Visoka pouzdanost: $highConfidenceOptOut"
} catch {
    # HighConfidenceOptOut nije obavezan – ne postoji u većini sustava
    $highConfidenceOptOut = $null
    Write-Host "Odustajanje visoke pouzdanosti: nije postavljeno"
}

# 4b. MicrosoftUpdateManagedOptIn
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Upravljana prijava servisa Microsoft Update: $microsoftUpdateManagedOptIn"
} catch {
    # MicrosoftUpdateManagedOptIn nije obavezan – ne postoji na većini sustava
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Upravljana prijava servisa Microsoft Update: nije postavljena"
}

# 5. Dostupna ažuriranja
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Pretvori u heksadecimalni oblik
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Dostupno Ažuriranja: $availableUpdatesHex"
    } else {
        Write-Host "Dostupno Ažuriranja: nije dostupno"
    }
} catch {
    Write-Warning "Ključ registra AvailableUpdates nije pronađen ili nije dostupan"
    $availableUpdates = $null
    Write-Host "Dostupno Ažuriranja: nije dostupno"
}

# 5b. AvailableUpdatesPolicy (trajna vrijednost koju kontrolira GPO)
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Pretvori u heksadecimalni oblik
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Pravilnik o dostupnosti Ažuriranja: $availableUpdatesPolicyHex"
    } else {
        Write-Host "Pravilnik o dostupnosti Ažuriranja: nije postavljeno"
    }
} catch {
    # AvailableUpdatesPolicy nije obavezan – postavlja se samo kada se primjenjuje
objekt pravilnika grupe     $availableUpdatesPolicy = $null
    Write-Host "Pravilnik o dostupnosti Ažuriranja: nije postavljeno"
}

# Registar: Ključ za servisiranje (3 vrijednosti)

# 6. UEFICA2023Status
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 "Ključ registra za status Windows UEFI CA 2023 nije pronađen ili nije dostupan"
    $uefica 2023Status = $null
    Write-Host "Status Windows UEFI CA 2023: nije dostupan"
}

# 7. UEFICA2023Error
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "Pogreška UEFI CA 2023: $uefica 2023Error"
} catch {
    # UEFICA2023Pogreška postoji samo ako je došlo do pogreške - odsutnost je dobra
    $uefica 2023Error = $null
    Write-Host "Pogreška UEFI CA 2023: Nema"
}

# 8. UEFICA2023ErrorEvent
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "Događaj pogreške UEFI CA 2023: $uefica 2023ErrorEvent"
} catch {
    $uefica 2023ErrorEvent = $null
    Write-Host "Događaj pogreške UEFI CA 2023: nije dostupan"
}

# Registar: Atributi uređaja (7 vrijednosti: 9 – 15)

# 9. OEMManufacturerName
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 is empty"
        $oemManufacturerName = "Nepoznato"
    }
    Write-Host "Naziv proizvođača OEM-a: $oemManufacturerName"
} catch {
    Write-Warning "Ključ registra OEMManufacturerName nije pronađen ili nije dostupan"
    $oemManufacturerName = $null
    Write-Host "Naziv proizvođača OEM-a: nije dostupan"
}

# 10. OEMModelSystemFamily
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 is empty"
        $oemModelSystemFamily = "Nepoznato"
    }
    Write-Host "Obitelj sustava OEM modela: $oemModelSystemFamily"
} catch {
    Write-Warning "Ključ registra OEMModelSystemFamily nije pronađen ili nije dostupan"
    $oemModelSystemFamily = $null
    Write-Host "Obitelj sustava OEM modela: nije dostupno"
}

# 11. OEMModelNumber
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 is empty"
        $oemModelNumber = "Nepoznato"
    }
    Write-Host "OEM broj modela: $oemModelNumber"
} catch {
    Write-Warning "Ključ registra OEMModelNumber nije pronađen ili nije dostupan"
    $oemModelNumber = $null
    Write-Host "OEM broj modela: nije dostupan"
}

# 12. FirmwareVersion
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 is empty"
        $firmwareVersion = "Nepoznato"
    }
    Write-Host "Verzija opreme: $firmwareVersion"
} catch {
    Write-Warning "Ključ registra FirmwareVersion nije pronađen ili nije dostupan"
    $firmwareVersion = $null
    Write-Host "Verzija opreme: nije dostupna"
}

# 13. FirmwareReleaseDate
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
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 is empty"
        $firmwareReleaseDate = "Nepoznato"
    }
    Write-Host "Datum izdavanja opreme: $firmwareReleaseDate"
} catch {
    Write-Warning "Ključ registra FirmwareReleaseDate nije pronađen ili nije dostupan"
    $firmwareReleaseDate = $null
    Write-Host "Datum izdavanja opreme: nije dostupan"
}

# 14. Zaslon OSArchitecture
# Verzija PS-a: Sve | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Isprobajte rezervu registra
        $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 nije moguće odrediti"
        $osArchitecture = "Nepoznato"
    }
    Write-Host "Arhitektura OS-a: $osArchitecture"
} catch {
    Write-Warning "Pogreška pri dohvaćanju OSArchitecture: $_"
    $osArchitecture = "Nepoznato"
    Write-Host "Arhitektura OS-a: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# Verzija PS-a: Sve | Administrator: Možda će biti potrebno | Sistemski preduvjeti: Nema
try {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Convert FILETIME u UTC DateTime – registry pohranjuje u obliku REG_BINARY (byte[]) ili 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 [dugo]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } catch {
            Write-Warning "Nije moguće pretvoriti CanAttemptUpdateAfter FILETIME u DateTime"
        }
    }
    Write-Host "Ažuriranje je moguće pokušati poslije: $canAttemptUpdateAfter"
} catch {
    Write-Warning "Ključ registra CanAttemptUpdateAfter nije pronađen ili nije dostupan"
    $canAttemptUpdateAfter = $null
    Write-Host "Ažuriranje je moguće pokušati nakon: nije dostupno"
}

# Zapisnici događaja: Zapisnik sustava (10 vrijednosti: 16 – 25)

# 16-25. Upiti zapisnika događaja
# ID-jevi događaja:
# 1801 – Ažuriranje je pokrenuto, potrebno
je ponovno pokretanje # 1808 – Ažuriranje je uspješno
dovršeno # 1795 – Oprema je vratila pogrešku (kôd pogreške snimanja)
# 1796 – Pogreška zabilježena kodom pogreške (kôd za snimanje)
# 1800 – Potrebno je ponovno pokretanje (NIJE pogreška – ažuriranje će se nastaviti nakon ponovnog pokretanja)
# 1802 – Poznati problem s programskom opremom blokirano je ažuriranje (broj KI_<snimanja> iz stavke SkipReason)
# 1803 – Nije pronađeno odgovarajuće ažuriranje za KEK (OEM mora isporučiti PK potpisani KEK)
# Verzija PS-a: 3.0+ | Administrator: Možda je potrebno za zapisnik sustava | Sistemski preduvjeti: Nema
try {
    # Slanje upita svim relevantnim ID-jevima događaja
sigurnog pokretanja sustava     $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 "U zapisniku sustava nema događaja sigurnog pokretanja"
        $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 "ID najnovijeg događaja: nije dostupan"
        Write-Host "ID grupe: nije dostupan"
        Write-Host "Povjerenost: nije dostupno"
        Write-Host "Event 1801 Count: 0"
        Write-Host "Event 1808 Count: 0"
    } else {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated – silazno | Select-Object – Prvo 1
        if ($null -eq $latestEvent) {
            Write-Warning "Nije moguće utvrditi najnoviji događaj"
            $latestEventId = $null
            Write-Host "ID najnovijeg događaja: nije dostupan"
        } else {
            $latestEventId = latestEvent.Id
$             Write-Host "ID najnovijeg događaja: $latestEventId"
        }

        # 17. BucketID – izdvojeno iz događaja 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trim()
                Write-Host "ID grupe: $bucketId"
            } else {
                Write-Warning "BucketId nije pronađen u poruci o događaju"
                $bucketId = $null
                Write-Host "ID grupe: nije pronađeno u događaju"
            }
        } else {
            Write-Warning "Najnoviji događaj ili poruka ima vrijednost null, nije moguće izdvojiti BucketId"
            $bucketId = $null
            Write-Host "ID grupe: nije dostupan"
        }

        # 18. Povjerenje – izdvojeno iz događaja 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trim()
                Write-Host "Pouzdanost: $confidence"
            } else {
                Write-Warning "Razina pouzdanosti nije pronađena u poruci o događaju"
                $confidence = $null
                Write-Host "Pouzdanost: nije pronađeno u događaju"
            }
        } else {
            Write-Warning "Najnoviji događaj ili poruka ima vrijednost null, ne može se izdvojiti pouzdanost"
            $confidence = $null
            Write-Host "Pouzdanost: nije dostupno"
        }

        # 18b. SkipReason – izdvoji KI_<broj> iz parametra SkipReason u istom događaju kao i BucketId
        # Ovo bilježi ID-ove poznatih problema koji se pojavljuju uz BucketId/Confidence (ne samo događaj 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 "PreskočiRazlog poznatog problema: $skipReasonKnownIssue" -foregroundColor Yellow
            }
        }

        # 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"
        
        # Inicijalizacija varijabli događaja
pogreške         $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
        
        # Provjeravaj ima li događaja s pogreškama samo ako ažuriranje NIJE dovršeno
        # Preskoči analizu pogrešaka ako: 1808 je najnoviji događaj ILI UEFICA2023Status je "Ažurirano"
        $updateComplete = ($latestEventId -eq 1808) -or ($uefica 2023Status -eq "Ažurirano")
        
        if (-not $updateComplete) {
            Write-Host "Ažuriranje nije dovršeno – provjera događaja pogrešaka..." -ForegroundColor Yellow
            
            # 21. Event1795 – Pogreška opreme (kôd pogreške snimanja)
            $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 – silazno | Select-Object – Prvo 1
                if ($latestEvent 1795.Message -match '(?:error|kod|status)[:\s]*(?:0x)?( [0-9A-Fa-f]{8}|[0-9A-Fa-f]+)') {
                    $event 1795ErrorCode = $matches[1]
                }
                Write-Host "Event 1795 (Firmware Error) Count: $event 1795Count" $(if ($event 1795ErrorCode) { "Code: $event 1795ErrorCode" })
            }
            
            # 22. Event1796 – Prijavljen je kod pogreške (kod pogreške snimanja)
            $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 – silazno | Select-Object – Prvo 1
                if ($latestEvent 1796.Message -match '(?:error|kod|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 – Potrebno je ponovno pokretanje (NIJE pogreška – ažuriranje će se nastaviti nakon ponovnog pokretanja)
            $event 1800Array = @($events | Where-Object {$_. ID -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt; 0
            if ($rebootPending) {
                Write-Host "Događaj 1800 (Reboot Pending): Update will proceed after reboot" -ForegroundColor Cyan
            }
            
            # 24. Event1802 – Poznati problem s opremom (broj KI_<snimanja> iz stavke 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 – silazno | Select-Object – Prvo 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Event 1802 (poznati problem s opremom) Count: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 – nedostaje ažuriranje za KEK (OEM mora isporučiti KEK s potpisom PK)
            $event 1803Array = @($events | Where-Object {$_. ID -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt; 0
            if ($missingKEK) {
                Write-Host "Događaj 1803 (nedostaje KEK): OEM mora isporučiti PK s potpisom KEK" -ForegroundColor Yellow
            }
        } else {
            Write-Host "Ažuriranje je dovršeno (Event 1808 or Status=Updated) - preskakanje analize pogrešaka" -ForegroundColor Green
        }
    }
} catch {
    Write-Warning "Pogreške pri dohvaćanju zapisnika događaja. Možda su potrebne administratorske ovlasti: $_"
    $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 "Najnoviji ID događaja: pogreška"
    Write-Host "ID grupe: pogreška"
    Write-Host "Pouzdanost: pogreška"
    Write-Host "Event 1801 Count: 0"
    Write-Host "Event 1808 Count: 0"
}

# WMI/CIM upiti (5 vrijednosti)

# 26. OSVersion
# Verzija PS-a: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nije moguće dohvatiti verziju OS-a"
        $osVersion = "Nepoznato"
    } else {
        $osVersion = $osInfo.Version
    }
    Write-Host "Verzija OS-a: $osVersion"
} catch {
    # CIM možda neće uspjeti u nekim okruženjima – koristite rezervu
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "Verzija OS-a: $osVersion"
}

# 27. LastBootTime
# Verzija PS-a: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nije moguće dohvatiti vrijeme zadnjeg pokretanja"
        $lastBootTime = $null
        Write-Host "Vrijeme zadnjeg pokretanja: nije dostupno"
    } else {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Vrijeme zadnjeg pokretanja: $lastBootTime"
    }
} catch {
    # CIM možda neće uspjeti u nekim okruženjima – koristite rezervu
    try {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Vrijeme
početka     } catch {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Vrijeme zadnjeg pokretanja: $lastBootTime" } else { Write-Host "Vrijeme zadnjeg pokretanja: nije dostupno" }
}

# 28. BaseBoardManufacturer
# Verzija PS-a: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Nije moguće dohvatiti proizvođača matične ploče"
        $baseBoardManufacturer = "Nepoznato"
    } else {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Proizvođač matične ploče: $baseBoardManufacturer"
} catch {
    # CIM možda neće uspjeti – informacije o matičnoj ploči su dopunske
    $baseBoardManufacturer = "Nepoznato"
    Write-Host "Proizvođač matične ploče: $baseBoardManufacturer"
}

# 29. BaseBoardProductProduct
# Verzija PS-a: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski preduvjeti: Nema
try {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nije moguće dohvatiti proizvod osnovne ploče"
        $baseBoardProduct = "Nepoznato"
    } else {
        $baseBoardProduct = $baseBoard.Proizvod
    }
    Write-Host "Proizvod osnovne ploče: $baseBoardProduct"
} catch {
    # CIM možda neće uspjeti – informacije o matičnoj ploči su dopunske
    $baseBoardProduct = "Nepoznato"
    Write-Host "Osnovni proizvod: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# Verzija PS-a: Sve | Administrator: Ne | Sistemski preduvjeti: postoji zakazani zadatak
# Provjerava je li omogućen
zakazani zadatak Sigurnog pokretanja i ažuriranja $secureBootTaskEnabled = $null
$secureBootTaskStatus = "Nepoznato"
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 'Spreman' -ili $taskData.Status -eq 'Izvršava se')
        }
    } else {
        $secureBootTaskStatus = "NijePronađeno"
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -foregroundColor Yellow
    } else {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -foregroundColor Green
    }
} catch {
    $secureBootTaskStatus = "Pogreška"
    $secureBootTaskEnabled = $false
    Write-Host "Zadatak ažuriranja SecureBoot: provjera pogrešaka – $_" -ForegroundColor Red
}

# 31. Stanje ključa WinCS (F33E0C8E002 – ažuriranje certifikata sigurnog pokretanja sustava)
# Verzija PS-a: Sve | Administrator: Da (za upit) | Sistemski preduvjeti: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Nepoznato"
try {
    # Provjera uobičajenih mjesta za WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
   
)     foreach ($p u $possiblePaths) {
        if (Test-Path $p) { $wincsFlagsPath = $p; prijelom }
    }

    if ($wincsFlagsPath) {
        # Ključ za određeni upit – potrebna su administratorska prava
        $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Provjerite je li tipka primijenjena (potražite pokazatelj "Aktivna konfiguracija" ili sličan pokazatelj)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Primijenjeno"
                Write-Host "WinCS Key F33E0C8E002: Applied" -foregroundColor Green
            } elseif ($queryOutputStr -match "nije pronađeno|Nema konfiguracije") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "Ključ WinCS F33E0C8E002: nije primijenjeno" -foregroundColor Yellow
            } else {
                # Key exists – check output for state
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Primijenjeno"
                Write-Host "WinCS Key F33E0C8E002: Applied" -foregroundColor Green
            }
        } else {
            # Provjera određenih poruka o
pogrešci             if ($queryOutputStr -match "Pristup odbijen|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS Key F33E0C8E002: Access denied (run as admin)" -ForegroundColor DarkGrey
            } elseif ($queryOutputStr -match "nije pronađeno|Nema konfiguracije") {
                $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 Grey
    }
} catch {
    $wincsKeyStatus = "Pogreška"
    Write-Host "WinCS Key F33E0C8E002: Error checking - $_" -foregroundColor Red
}              

# =============================================================================
# Otkrivanje popravka – izlazni & izlazni kod
statusa # =============================================================================

# Build status objekt iz svih prikupljenih podataka
o inventaru $status = [naručeno]@{
    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 }
    Hostname = $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
    Pouzdanost = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<broj> iz SkipReason u događaju
BucketId     Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Događaji pogreške sa zabilježenim pojedinostima
    Event1795Count = $event 1795Count # Vraćena pogreška
opreme     Event1795ErrorCode = $event 1795ErrorCode # kôd pogreške iz programske opreme
    Event1796Count = $event 1796Count # Zapisani
kod pogreške     Event1796ErrorCode = $event 1796ErrorCode # zabilježeni kôd
pogreške     Event1800Count = $event 1800Count # Potrebno je ponovno pokretanje (NIJE pogreška)
    RebootPending = $rebootPending # istinito ako je prisutan
događaj 1800     Event1802Count = $event 1802Count # Poznati problem
opreme     KnownIssueId = $knownIssueId # broj KI_<> iz parametra SkipReason
    Event1803Count = $event 1803Count # Nedostaje ažuriranje
za KEK     MissingKEK = $missingKEK # OEM mora isporučiti PK potpisani KEK
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True ako je F33E0C8E002 ključ primijenjen
    WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound itd.
}

# Izlaz statusa – za agregaciju
podataka $jsonOutput = $status | ConvertTo-Json – komprimiranje

# Ako je naveden OutputPath, spremi u datoteku; U suprotnom izlaz na stdout
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Provjera valjanosti OutputPath – preskočite ako izgleda kao zahtjev za pomoć ili sadrži znakove
koji nisu valjani     if ($OutputPath -match '^[/\-]' -ili $OutputPath -match '[<>:"|? *]') {
        Write-Host "Invalid OutputPath specified, outoutput to stdout" -ForegroundColor Yellow
        Write-Output $jsonOutput
        if ($secureBootEnabled -and $uefica 2023Status -eq "Ažurirano") { izlaz 0 } else { izlaz 1 }
    }
    
    # Provjerite postoji li
izlazna mapa     if (-not (Test-Path $OutputPath)) {
        try {
            New-Item -ItemType Directory -Path $OutputPath -Force | Izvan vrijednosti
null         } catch {
            Write-Warning "Nije moguće stvoriti izlaznu mapu: $OutputPath - $_"
        }
    }
    
    # Spremi u HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    try {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 -Force
        Write-Host "JSON spremljen u: $outputFile" -ForegroundColor Green
    } catch {
        Write-Warning "Nije moguće pisati u datoteku: $outputFile - $_"
        # Vraćanje na stdout
        Write-Output $jsonOutput
    }
} else {
    # Izvorno ponašanje – izlaz na stdout
    Write-Output $jsonOutput
}

# Izlazni kod: "Ažurirano" je vrijednost uspjeha prema proceduralnom priručniku
if ($secureBootEnabled -and $uefica 2023Status -eq "Ažurirano") {
    izlaz 0 # Bez problema
} else {
    izlaz 1 # S problemom
}