Uzorak skripte prikupljanja podataka o zalihama bezbednog pokretanja sistema

<#
. SINOPSIS
    Otkriva status ažuriranja certifikata bezbednog pokretanja za nadgledanje na nivou flote.

. OPIS
    Ova skripta za otkrivanje prikuplja status bezbednog pokretanja, vrednosti registratora ažuriranja certifikata,
    i informacije o uređaju. Ona izvozi JSON nisku za nadgledanje i izveštavanje.

    Kompatibilno sa Intune ispravkama, kolekcijom zasnovanom na GPO i drugim alatkama za upravljanje.
Nije potrebna skripta za ponovno rešavanje problema – ovo je samo nadgledanje.

    Izlaz 0 = "Bez problema" (certifikati su ažurirani)
    Izlaz 1 = "Sa problemom" (certifikati nisu ažurirani – samo informativno)

. IZLAZNI PARAMETAR
    Opcionalno. Putanja do fascikle u kojoj će JSON datoteka biti sačuvana.
Ako je obezbeđena, čuva HOSTNAME_latest.json u ovoj fascikli.
Ako nije obezbeđen, izvezi JSON u stdout (originalno ponašanje).

. PRIMER
    # Izlaz u stdout (Intune/SCCM otkrivanje)
    .\Detect-SecureBootCertUpdateStatus.ps1

. PRIMER
    # Sačuvaj na mrežnom resursu (GPO primena)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. BELEŠKE
    Putanje registratora po https://aka.ms/securebootplaybook:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    SOFTVER SE PRUŽA "KAKAV JESTE", BEZ BILO KAKVE GARANCIJE, IZRIČITE ILI
    PODRAZUMEVANO, UKLJUČUJUĆI, ALI NE OGRANIČAVAJUĆI SE NA GARANCIJE ZA PODSTIČU NA RASPOREĐENU ROBU,
    PODSTIČE SE NA ODREĐENU NAMENU I NEOŠTEĆENO. NI U KOJEM SE DOGAĐAJU NEĆE
    AUTORI ILI AUTORI KOJI DRŽE AUTORSKA PRAVA SNOSE ODGOVORNOST ZA BILO KAKVE ZAHTEVE, ŠTETE ILI DRUGE
    ODGOVORNOST, BILO U RADNJI UGOVORA, DELIKATESA ILI NA NEKI DRUGI NAČIN, NA OSNOVU
    VAN ILI U VEZI SA SOFTVEROM, UPOTREBOM ILI DRUGIM POSLOVAMA U
    SOFTVER.
#>
param(
    [Parameter(Obavezno = $false)]
    [niska]$OutputPath
)

# Preuzmi URL: https://aka.ms/getsecureboot -> "Uzorci primene i nadgledanja"
# Napomena: Ova skripta se pokreće na krajnjim tačkama radi prikupljanja podataka o statusu bezbednog pokretanja.

# 1. Ime hosta
# PS verzija: Sve | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $hostname = $env:COMPUTERNAME
    if ([niska]::IsNullOrEmpty($hostname)) {
        Write-Warning "Nije moguće utvrditi ime hosta"
        $hostname = "Nepoznato"
    }
    Write-Host "Ime hosta: $hostname"
} hvatanje {
    Write-Warning "Greška pri dobavljanju imena hosta: $_"
    $hostname = "Greška"
    Write-Host "Ime hosta: $hostname"
}

# 2. Vreme prikupljanja
# PS verzija: Sve | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $collectionTime = Get-Date
    if ($null -eq $collectionTime) {
        Write-Warning "Nije moguće preuzeti trenutni datum/vreme"
        $collectionTime = "Nepoznato"
    }
    Write-Host "Vreme kolekcije: $collectionTime"
} hvatanje {
    Write-Warning "Greška pri preuzimanju datuma/vremena: $_"
    $collectionTime = "Greška"
    Write-Host "Vreme kolekcije: $collectionTime"
}

# Registrator: Glavni ključ bezbednog pokretanja (3 vrednosti)

# 3. SecureBootEnabled
# PS verzija: 3.0+ | Administrator: može biti potrebno | Sistemski zahtevi: sistem omogućen za UEFI/bezbedno pokretanje sistema
pokušajte {
    $secureBootEnabled = Confirm-SecureBootUEFI -Prekid greške
    Write-Host "Omogućeno bezbedno pokretanje sistema: $secureBootEnabled"
} hvatanje {
    Write-Warning "Nije moguće utvrditi status bezbednog pokretanja putem cmdlet komande: $_"
    # Isprobajte povratne informacije u registratoru
    pokušajte {
        $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Omogućeno bezbedno pokretanje sistema: $secureBootEnabled"
    } hvatanje {
        Write-Warning "Nije moguće utvrditi status bezbednog pokretanja putem registratora. Sistem možda ne podržava UEFI/bezbedno pokretanje."
        $secureBootEnabled = $null
        Write-Host "Omogućeno bezbedno pokretanje sistema: nije dostupno"
    }
}

# 4. HighConfidenceOptOut
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Odbijanje saglasnosti visokog stepena pouzdanosti: $highConfidenceOptOut"
} hvatanje {
    # HighConfidenceOptOut je opcionalno – nije prisutan u većini sistema
    $highConfidenceOptOut = $null
    Write-Host "Odbijanje saglasnosti visokog stepena pouzdanosti: nije postavljeno"
}

# 4b. MicrosoftUpdateManagedOptIn
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed Dat In: $microsoftUpdateManagedOptIn"
} hvatanje {
    # MicrosoftUpdateManagedOptIn je opcionalno – nije prisutan u većini sistema
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed Dat In: Not Set"
}

# 5. Dostupne ispravke
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Konvertuj u heksadecimalni format
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Dostupno Novosti: $availableUpdatesHex"
    } još {
        Write-Host "Dostupno Novosti: Nije dostupno"
    }
} hvatanje {
    Write-Warning "AvailableUpdates ključ registratora nije pronađen ili nedostupan"
    $availableUpdates = $null
    Write-Host "Dostupno Novosti: Nije dostupno"
}

# 5b. AvailableUpdatesPolicy (trajna vrednost koju kontroliše GPO)
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Konvertuj u heksadecimalni format
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Dostupne Novosti: $availableUpdatesPolicyHex"
    } još {
        Write-Host "Dostupne Novosti: nije postavljeno"
    }
} hvatanje {
    # AvailableUpdatesPolicy je opcionalno – podešeno samo kada se primenjuje GPO
    $availableUpdatesPolicy = $null
    Write-Host "Dostupne Novosti smernice: nije postavljeno"
}

# Registrator: Ključ za servisiranje (3 vrednosti)

# 6. UEFICA2023Status
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 status: $uefica 2023Status"
} hvatanje {
    Write-Warning "Ključ registratora Windows UEFI CA 2023 statusa nije pronađen ili nedostupan"
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 status: Nije dostupno"
}

# 7. UEFICA2023Greška
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "UEFI CA 2023 greška: $uefica 2023Greška"
} hvatanje {
    # UEFICA2023Greška postoji samo ako je došlo do greške - odsustvo je dobro
    $uefica 2023Error = $null
    Write-Host "UEFI CA 2023 greška: nijedno"
}

# 8. UEFICA2023ErrorEvent
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "Događaj greške UEFI CA 2023: $uefica 2023ErrorEvent"
} hvatanje {
    $uefica 2023ErrorEvent = $null
    Write-Host "Događaj greške UEFI CA 2023: Nije dostupno"
}

# Registrator: Atributi uređaja (7 vrednosti: 9-15)

# 9. OEMManufacturerName
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([niska]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName je prazno"
        $oemManufacturerName = "Nepoznato"
    }
    Write-Host "Ime proizvođača OEM proizvođača: $oemManufacturerName"
} hvatanje {
    Write-Warning "OEMManufacturerName ključ registratora nije pronađen ili nedostupan"
    $oemManufacturerName = $null
    Write-Host "Ime proizvođača OEM proizvođača: nije dostupno"
}

# 10. OEMModelSystemFamily
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([niska]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily je prazan"
        $oemModelSystemFamily = "Nepoznato"
    }
    Write-Host "Porodica sistema OEM modela: $oemModelSystemFamily"
} hvatanje {
    Write-Warning "OEMModelSystemFamily ključ registratora nije pronađen ili nedostupan"
    $oemModelSystemFamily = $null
    Write-Host "OEM Model System Family: Not available"
}

# 11. OEMModelNumber
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([niska]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber je prazan"
        $oemModelNumber = "Nepoznato"
    }
    Write-Host "Broj OEM modela: $oemModelNumber"
} hvatanje {
    Write-Warning "OEMModelNumber ključ registratora nije pronađen ili nedostupan"
    $oemModelNumber = $null
    Write-Host "Broj OEM modela: nije dostupan"
}

# 12. Verzija firmvera
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([niska]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion je prazna"
        $firmwareVersion = "Nepoznato"
    }
    Write-Host "Verzija firmvera: $firmwareVersion"
} hvatanje {
    Write-Warning "Ključ registratora FirmwareVersion nije pronađen ili nedostupan"
    $firmwareVersion = $null
    Write-Host "Verzija firmvera: nije dostupna"
}

# 13. FirmwareReleaseDate
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([niska]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate je prazan"
        $firmwareReleaseDate = "Nepoznato"
    }
    Write-Host "Datum izdavanja firmvera: $firmwareReleaseDate"
} hvatanje {
    Write-Warning "FirmwareReleaseDate ključ registratora nije pronađen ili nedostupan"
    $firmwareReleaseDate = $null
    Write-Host "Datum izdavanja firmvera: nije dostupan"
}

# 14. OSArchitecture
# PS verzija: Sve | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([niska]::IsNullOrEmpty($osArchitecture)) {
        # Isprobajte povratne informacije u registratoru
        $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([niska]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "Nije moguće utvrditi OSArchitecture"
        $osArchitecture = "Nepoznato"
    }
    Write-Host "Arhitektura operativnog sistema: $osArchitecture"
} hvatanje {
    Write-Warning "Greška pri dobavljanju OSArchitecture: $_"
    $osArchitecture = "Nepoznato"
    Write-Host "Arhitektura operativnog sistema: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS verzija: Sve | Administrator: može biti potrebno | Sistemski zahtevi: nijedan
pokušajte {
    $regValue = Get-ItemProperty -Putanja "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Konvertuj FILETIME u UTC DateTime – skladišta u registratoru kao REG_BINARY (bajt[]) ili REG_QWORD (dugački)
    if ($null -ne $canAttemptUpdateAfter) {
        pokušajte {
            if ($canAttemptUpdateAfter -is [byte[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } hvatanje {
            Write-Warning "Nije moguće konvertovati CanAttemptUpdateAfter FILETIME u DateTime"
        }
    }
    Write-Host "Može da pokuša ažuriranje posle: $canAttemptUpdateAfter"
} hvatanje {
    Write-Warning "CanAttemptUpdateAfter ključ registratora nije pronađen ili nedostupan"
    $canAttemptUpdateAfter = $null
    Write-Host "Može da pokuša ažuriranje posle: nije dostupno"
}

# Evidencije događaja: Sistemska evidencija (10 vrednosti: 16-25)

# 16-25. Upiti za evidenciju događaja
# ID-ovi događaja:
# 1801 - Pokrenuta je ispravka, potrebno je ponovno pokretanje
# 1808 - Ažuriranje je uspešno dovršeno
# 1795 - Firmver je vratio grešku (uhvati kôd greške)
# 1796 - Greška evidentirana pomoću koda greške (kôd hvatanja)
# 1800 - Potrebno je ponovno pokretanje (NOT greška - ažuriranje će se nastaviti nakon ponovnog pokretanja sistema)
# 1802 - Poznati problem sa firmverom je blokirao ažuriranje (KI_<broj> Iz programa SkipReason)
# 1803 - Nije pronađena odgovarajuća KEK ispravka (OEM mora da obezbedi KEK potpisan sa PK)
# PS verzija: 3.0+ | Administrator: možda će biti potrebno za sistemsku evidenciju | Sistemski zahtevi: nijedan
pokušajte {
    # Izvrši upit za sve relevantne ID-e događaja bezbednog pokretanja
    $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    ako ($events. Broj -eq 0) {
        Write-Warning "Nije pronađen nijedan događaj bezbednog pokretanja u evidenciji sistema"
        $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: nije dostupan"
        Write-Host "ID grupe: nije dostupan"
        Write-Host "Pouzdanost: nije dostupno"
        Write-Host "Događaj 1801 Broj: 0"
        Write-Host "Događaj 1808 Count: 0"
    } još {
        # 16. NajnovijiId
        $latestEvent = $events | Sort-Object -Opadajući redosled | Select-Object - Prvih 1
        if ($null -eq $latestEvent) {
            Write-Warning "Nije moguće utvrditi najnoviji događaj"
            $latestEventId = $null
            Write-Host "Najnoviji ID događaja: nije dostupan"
        } još {
            $latestEventId = $latestEvent.Id
            Write-Host "Najnoviji ID događaja: $latestEventId"
        }

        # 17. BucketID – izdvojena iz događaja 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message - podudaranje 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Skrati()
                Write-Host "ID kontejnera: $bucketId"
            } još {
                Write-Warning "ID grupe nije pronađen u poruci o događaju"
                $bucketId = $null
                Write-Host "ID grupe: nije pronađen u događaju"
            }
        } još {
            Write-Warning "Najnoviji događaj ili poruka su bez vrednosti, nije moguće izdvojiti ID grupe"
            $bucketId = $null
            Write-Host "ID grupe: nije dostupan"
        }

        # 18. Confidence – izdvojeno iz događaja 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Skrati()
                Write-Host "Pouzdanost: $confidence"
            } još {
                Write-Warning "Nivo pouzdanosti nije pronađen u poruci događaja"
                $confidence = $null
                Write-Host "Pouzdanost: nije pronađeno u događaju"
            }
        } još {
            Write-Warning "Najnoviji događaj ili poruka su bez vrednosti, nije moguće izdvojiti pouzdanost"
            $confidence = $null
            Write-Host "Pouzdanost: nije dostupno"
        }

        # 18b. SkipReason – izdvoji KI_<broj> iz funkcije SkipReason u istom događaju kao i ID
grupe         # Ovo hvata ID-ove poznatog problema koji se pojavljuju zajedno sa ID-om kontejnera/pouzdanošću (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 "Poznati problem preskoči reason: $skipReasonKnownIssue" -Boja prednjeg plana žuta
            }
        }

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

        # 20. Event1808Count
        $event 1808Array = @($events | Where-Object {$_. Id -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Događaj 1808 Count: $event 1808Count"
        
        # Pokretanje promenljivih događaja greš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
        
        # Proverite da li postoje događaji grešaka samo ako ažuriranje NIJE dovršeno
        # Preskoči analizu grešaka ako: 1808 je najnoviji događaj OR UEFICA2023Status je "Ažurirano"
        $updateComplete = ($latestEventId -eq 1808) -ili ($uefica 2023Status -eq "Ažurirano")
        
        ako (-ne $updateComplete) {
            Write-Host "Ažuriranje nije dovršeno – provera da li postoje događaji grešaka..." - Boja prednjeg plana žuta
            
            # 21. Event1795 - Greška firmvera (uhvati kôd greške)
            $event 1795Array = @($events | Where-Object {$_. Id -eq 1795})
            $event 1795Count = $event 1795Array.Count
            if ($event 1795Count -gt 0) {
                $latestEvent 1795 = $event 1795Array | Sort-Object -Opadajući redosled | Select-Object - Prvih 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 "Broj događaja 1795 (greška firmvera): $event 1795Count" $(if ($event 1795ErrorCode) { "Kôd: $event 1795ErrorCode" })
            }
            
            # 22. Event1796 – Evidentirani kôd greške (uhvati kôd greške)
            $event 1796Array = @($events | Where-Object {$_. Id -eq 1796})
            $event 1796Count = $event 1796Array.Count
            if ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object -Opadajući redosled | Select-Object - Prvih 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 "Događaj 1796 (evidentirano greškama): $event 1796Count" $(if ($event 1796ErrorCode) { "Kôd: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 - Potrebno je ponovno pokretanje (NOT greš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
            ako ($rebootPending) {
                Write-Host "Događaj 1800 (ponovno pokretanje je na čekanju): Ažuriranje će se nastaviti nakon ponovnog pokretanja sistema" -Prednji planColor Cyan
            }
            
            # 24. Event1802 - Poznati problem sa firmverom (beležite KI_<broj> Funkcije 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 -Opadajući redosled | Select-Object - Prvih 1
                if ($latestEvent 1802.Message -match "SkipReason:\s*(KI_\d+)") {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Događaj 1802 (poznati problem firmvera) Prebrojavanje: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 - Nedostaje KEK ispravka (OEM mora da obezbedi KEK potpisan sa PK)
            $event 1803Array = @($events | Where-Object {$_. Id -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            ako ($missingKEK) {
                Write-Host "Događaj 1803 (nedostaje KEK): OEM mora da obezbedi POTPISANI KEK" -Prednji planColor Žuto
            }
        } još {
            Write-Host "Ažuriranje je dovršeno (Događaj 1808 ili Status=Ažurirano) - preskakanje analize grešaka" -Boja prednjeg plana
– zelena         }
    }
} hvatanje {
    Write-Warning "Greška pri preuzimanju evidencija događaja. Možda će biti potrebne administratorske privilegije: $_"
    $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: greška"
    Write-Host "ID grupe: greška"
    Write-Host "Pouzdanost: greška"
    Write-Host "Događaj 1801 Broj: 0"
    Write-Host "Događaj 1808 Count: 0"
}

# WMI/CIM upiti (5 vrednosti)

# 26. Verzija operativnog sistema
# PS verzija: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $osInfo = Get-CimInstance Win32_OperatingSystem -Prekid greške
    if ($null -eq $osInfo -ili [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nije moguće preuzeti verziju operativnog sistema"
        $osVersion = "Nepoznato"
    } još {
        $osVersion = $osInfo.Version
    }
    Write-Host "Verzija operativnog sistema: $osVersion"
} hvatanje {
    # CIM možda neće uspeti u nekim okruženjima – koristite povratne informacije
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([niska]::IsNullOrEmpty($osVersion)) { $osVersion = "Nepoznato" }
    Write-Host "Verzija operativnog sistema: $osVersion"
}

# 27. Vreme poslednjeg pokretanja
# PS verzija: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $osInfo = Get-CimInstance Win32_OperatingSystem -Prekid greške
    if ($null -eq $osInfo -ili $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nije moguće preuzeti vreme poslednjeg pokretanja"
        $lastBootTime = $null
        Write-Host "Vreme poslednjeg pokretanja: nije dostupno"
    } još {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Vreme poslednjeg pokretanja: $lastBootTime"
    }
} hvatanje {
    # CIM možda neće uspeti u nekim okruženjima – koristite povratne informacije
    pokušajte {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Vreme početka
    } hvatanje {
        $lastBootTime = $null
    }
    ako ($lastBootTime) { Write-Host "Vreme poslednjeg pokretanja: $lastBootTime" } još { Write-Host "Vreme poslednjeg pokretanja: Nije dostupno" }
}

# 28. BaseBoardManufacturer
# PS verzija: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $baseBoard = Get-CimInstance Win32_BaseBoard -Tačka greške
    if ($null -eq $baseBoard -ili [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Nije moguće preuzeti proizvođača osnovne table"
        $baseBoardManufacturer = "Nepoznato"
    } još {
        $baseBoardManufacturer = $baseBoard.Proizvođač
    }
    Write-Host "Proizvođač osnovne table: $baseBoardManufacturer"
} hvatanje {
    # CIM možda ne uspe - informacije o osnovnoj tabli su dodatne
    $baseBoardManufacturer = "Nepoznato"
    Write-Host "Proizvođač baze table: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS verzija: 3.0+ (koristite Get-WmiObject za 2.0) | Administrator: Ne | Sistemski zahtevi: nijedan
pokušajte {
    $baseBoard = Get-CimInstance Win32_BaseBoard -Tačka greške
    if ($null -eq $baseBoard -ili [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nije bilo moguće preuzeti proizvod sa osnovne table"
        $baseBoardProduct = "Nepoznato"
    } još {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Osnovni proizvod: $baseBoardProduct"
} hvatanje {
    # CIM možda ne uspe - informacije o osnovnoj tabli su dodatne
    $baseBoardProduct = "Nepoznato"
    Write-Host "Osnovni proizvod: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS verzija: Sve | Administrator: Ne | Sistemski zahtevi: Planirani zadatak postoji
# Proverava da li je zadatak "Bezbedno pokretanje-ažuriranje" omogućen
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Nepoznato"
pokušajte {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    if ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | ConvertFrom-Csv
        ako ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq "Spremno" -ili $taskData.Status -eq "Pokrenuto")
        }
    } još {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (omogućeno: $secureBootTaskEnabled)" -ForegroundColor Yellow
    } još {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (omogućeno: $secureBootTaskEnabled)" -ForegroundColor Green
    }
} hvatanje {
    $secureBootTaskStatus = "Greška"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. WinCS key Status (F33E0C8E002 - ažuriranje certifikata za bezbedno pokretanje)
# PS verzija: Sve | Administrator: Da (za upit) | Sistemski zahtevi: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Nepoznato"
pokušajte {
    # Proveri uobičajene lokacije za 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 }
    }

    ako ($wincsFlagsPath) {
        # Ključ specifičan za upit – zahteva administratorska prava
        $queryOutput = & $wincsFlagsPath /query -- ključ F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Proverite da li je taster primenjen (potražite stavku "Aktivna konfiguracija" ili slični indikator)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -ili $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Primenjeno"
                Write-Host "WinCS key F33E0C8E002: Applied" -ForegroundColor Green
            } elseif ($queryOutputStr -match "not found|Bez konfiguracije") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } još {
                # Ključ postoji - odjavljivanje za stanje
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Primenjeno"
                Write-Host "WinCS key F33E0C8E002: Applied" -ForegroundColor Green
            }
        } još {
            # Proveri da li postoje određene poruke o grešci
            if ($queryOutputStr -match "Access denied|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS key F33E0C8E002: Access denied (run as admin)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "not found|Bez konfiguracije") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } još {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "WinCS key F33E0C8E002: Query failed" -ForegroundColor Red
            }
        }
    } još {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS ključ F33E0C8E002: WinCsFlags.exe nije pronađen" - Boja prednjeg plana siva
    }
} hvatanje {
    $wincsKeyStatus = "Greška"
    Write-Host "WinCS key F33E0C8E002: Error checking - $_" -ForegroundColor Red
}              

# =============================================================================
# Otkrivanje remediation - Izlaz statusa & izlazni kôd
# =============================================================================

# Gradi objekat statusa iz svih prikupljenih podataka o zalihama
$status = [poručeno]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Error = $uefica 2023Greška
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = if ($null -ne $availableUpdates) { $availableUpdatesHex } else { $null }
    AvailableUpdatesPolicy = if ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } else { $null }
    Ime hosta = $hostname
    CollectionTime = if ($collectionTime -is [datetime]) { $collectionTime.ToString("o") } else { "$collectionTime" }
    SecureBootEnabled = $secureBootEnabled
    HighConfidenceOptOut = $highConfidenceOptOut
    MicrosoftUpdateManagedOptIn = $microsoftUpdateManagedOptIn
    OEMManufacturerName = $oemManufacturerName
    OEMModelSystemFamily = $oemModelSystemFamily
    OEMModelNumber = $oemModelNumber
    Firmververzija = $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> od događaja SkipReason u događaju BucketId
    Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Događaji grešaka sa snimljenim detaljima
    Event1795Count = $event 1795Count # Firmver je vratio grešku
    Event1795ErrorCode = $event 1795ErrorCode # Kôd greške iz firmvera
    Event1796Count = $event 1796Count # Evidentirani kôd greške
    Event1796ErrorCode = $event 1796ErrorCode # Captured error code
    Event1800Count = $event 1800Count # Potrebno je ponovno pokretanje (NOT greška)
    Ponovno pokretanje na čekanju = $rebootPending # True ako je prisutan događaj 1800
    Event1802Count = $event 1802Count # Poznat problem sa firmverom
    KnownIssueId = $knownIssueId # KI_<broj> funkcije SkipReason
    Event1803Count = $event 1803Count # Nedostaje KEK ispravka
    MissingKEK = $missingKEK # OEM mora da obezbedi potpisani KEK sa PK-om
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True ako F33E0C8E002 se primeni ključ
    WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound itd.
}

# Output the status - For data agregation
$jsonOutput = $status | ConvertTo-Json - Komprimuj

# Ako je obezbeđen OutputPath, sačuvaj u datoteku; u suprotnom, izlaz u stdout
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Validate OutputPath - preskoči ako izgleda kao zahtev za pomoć ili ima nevažeće znakove
    ako ($OutputPath -podudaranje "^[/\-]" -ili $OutputPath -match "[<>:"|? *]') {
        Write-Host "Naveden je nevažeći outputPath, izlaz u stdout" -Boja prednjeg plana žuta
       
Write-Output $jsonOutput         if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") { exit 0 } else { exit 1 }
    }
    
    # Uverite se da izlazna fascikla postoji
    if (-not (test-path $OutputPath)) {
        pokušajte {
            New-Item -ItemType direktorijum -Putanja $OutputPath -Force | Bez vrednosti
        } hvatanje {
            Write-Warning "Nije moguće kreirati izlaznu fasciklu: $OutputPath - $_"
        }
    }
    
    # Sačuvaj u HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    pokušajte {
        $jsonOutput | Out-File -FilePath $outputFile -Šifrovanje UTF8 -Force
        Write-Host "JSON sačuvan u: $outputFile" - Zelena boja prednjeg plana
    } hvatanje {
        Write-Warning "Nije moguće pisati u datoteku: $outputFile - $_"
        # Vratite se u stdout
       
Write-Output $jsonOutput     }
} još {
    # Original behavior - out out to stdout
   
Write-Output $jsonOutput }

# Izlazni kôd: "Ažurirano" je vrednost uspeha po beležnici
if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") {
    izađi 0 # bez problema
} još {
    izađi 1 # Sa problemom
}