Secure Boot Inventory Data Collectioni skripti näidis

<#
. SÜNOPSIS
    Tuvastab turvalise algkäivituse serdi värskenduse oleku kogu laevastikuülese jälgimise jaoks.

. KIRJELDUS
    See tuvastusskript kogub secure Booti olekut, serdi värskendamise registriväärtusi,
    ja seadme teave. See väljastab JSON-stringi seireks ja aruandluseks.

    Ühildub Intune paranduste, GPO-põhise kogumi ja muude haldustööriistadega.
Parandusskripti pole vaja – see on ainult jälgimine.

    Exit 0 = "Without issue" (serdid värskendatud)
    Exit 1 = "With issue" (serdid pole värskendatud – ainult informaalne)

. PARAMETER OutputPath
    Vabatahtlik. JSON-faili salvestuskausta tee.
Kui see on esitatud, salvestab HOSTNAME_latest.json sellesse kausta.
Kui seda ei esitata, väljastab JSON-i stdout (algne käitumine).

. NÄIDE
    # Väljund stdout (Intune/SCCM tuvastamine)
    .\Detect-SecureBootCertUpdateStatus.ps1

. NÄIDE
    # Salvesta võrgukettale (GPO juurutus)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. MÄRKMED
    Registriteed https://aka.ms/securebootplaybook kohta:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    TARKVARA PAKUTAKSE "NAGU ON", ILMA IGASUGUSE GARANTIITA, EXPRESS VÕI
    KAUDSED, SEALHULGAS, KUID MITTE AINULT, KAUBASTATAVUSE GARANTIID,
    SOBIV KONKREETSEKS OTSTARBEKS JA MITTEINFRINGEMENTIMISEKS. MITTE MINGIL JUHUL EI TOHI
    AUTORID VÕI AUTORIÕIGUSE OMANIKUD VASTUTAVAD MIS TAHES NÕUETE, KAHJUDE VÕI MUUDE
KAHJUDE EEST     VASTUTUS, MIS TULENEB LEPINGULISEST TEGEVUSEST, LEPINGUVÄLISEST KAHJUST VÕI MUUL VIISIL,
MIS TULENEB     VÕI SEOSES TARKVARAGA VÕI SELLE KASUTAMISEGA VÕI MUUDE TEHINGUTEGA
    TARKVARA.
#>
param(
    [Parameter(Mandatory = $false)]
    [string]$OutputPath
)

# Allalaadimise URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples"
# Märkus. See skript töötab lõpp-punktides Secure Booti olekuandmete kogumiseks.

# 1. Hostname
PS-i versioon: kõik | Haldus: ei | Süsteeminõuded: pole
proovige {
    $hostname = $env:COMPUTERNAME
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Hostinime ei saanud määratleda"
        $hostname = "Tundmatu"
    }
    Write-Host "Hostname: $hostname" (Hostinimi: $hostname)
} püüdmine {
    Write-Warning "Hostinime toomisel ilmnes tõrge: $_"
    $hostname = "Tõrge"
    Write-Host "Hostname: $hostname"
}

# 2. Kogumisaeg
PS-i versioon: kõik | Haldus: ei | Süsteeminõuded: pole
proovige {
    $collectionTime = toomiskuupäev
    if ($null -eq $collectionTime) {
        Write-Warning "Praegust kuupäeva/kellaaega ei saanud tuua"
        $collectionTime = "Tundmatu"
    }
    Write-Host "Kogumisaeg: $collectionTime"
} püüdmine {
    Write-Warning "Kuupäeva/kellaaja toomisel ilmnes tõrge: $_"
    $collectionTime = "Tõrge"
    Write-Host "Kogumisaeg: $collectionTime"
}

# Registry: Secure Boot Main Key (3 väärtust)

# 3. SecureBootEnabled
# PS versioon: 3.0+ | Haldus: võib olla vajalik | Süsteeminõuded: UEFI/Secure Booti toega süsteem
proovige {
    $secureBootEnabled = Confirm-SecureBootUEFI –ErrorAction Stop
    Write-Host "Secure Boot Enabled: $secureBootEnabled"
} püüdmine {
    Write-Warning "Secure Booti olekut ei saa cmdlet-käsu kaudu määratleda: $_"
    # Proovige registri taandeid
    proovige {
        $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Secure Boot Enabled: $secureBootEnabled"
    } püüdmine {
        Write-Warning "Secure Booti olekut ei saa registri kaudu määratleda. Süsteem ei pruugi UEFI-liidese/secure Booti toetada."
        $secureBootEnabled = $null
        Write-Host "Turvaline käivitamine lubatud: pole saadaval"
    }
}

# 4. HighConfidenceOptOut
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut –ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Väga kindlustundega loobumine: $highConfidenceOptOut"
} püüdmine {
    # HighConfidenceOptOut on valikuline – pole enamikus süsteemides
saadaval     $highConfidenceOptOut = $null
    Write-Host "Väga kindlustundega loobumine: pole määratud"
}

# 4b. MicrosoftUpdateManagedOptIn
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update'i hallatav lubamine: $microsoftUpdateManagedOptIn"
} püüdmine {
    # MicrosoftUpdateManagedOptIn on valikuline – pole enamikus süsteemides
saadaval     $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update'i hallatav lubamine: pole määratud"
}

# 5. AvailableUpdates
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Teisenda kuueteistkümnendvormingusse
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Saadaolevad Teabevärskendused: $availableUpdatesHex"
    } else {
        Write-Host "Saadaval Teabevärskendused: pole saadaval"
    }
} püüdmine {
    Write-Warning "AvailableUpdates registrivõtit ei leitud või puudub juurdepääs"
    $availableUpdates = $null
    Write-Host "Saadaval Teabevärskendused: pole saadaval"
}

# 5b. AvailableUpdatesPolicy (GPO kontrollitud püsiv väärtus)
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy –ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Teisenda kuueteistkümnendvormingusse
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Saadaolev Teabevärskendused poliitika: $availableUpdatesPolicyHex"
    } else {
        Write-Host "Saadaval Teabevärskendused poliitika: määramata"
    }
} püüdmine {
    # AvailableUpdatesPolicy on valikuline – määratud ainult siis, kui GPO on rakendatud
    $availableUpdatesPolicy = $null
    Write-Host "Saadaval Teabevärskendused poliitika: määramata"
}

# Registry: Teenindusvõti (3 väärtust)

# 6. UEFICA2023Status
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Status –ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 olek: $uefica 2023Status"
} püüdmine {
    Write-Warning "Windows UEFI CA 2023 oleku registrivõtit ei leitud või puudub juurdepääs"
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 olek: pole saadaval"
}

# 7. UEFICA2023Error
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "UEFI CA 2023 tõrge: $uefica 2023Error"
} püüdmine {
    # UEFICA2023Tõrge on olemas ainult siis, kui ilmnes tõrge – puudumine on hea
    $uefica 2023Error = $null
    Write-Host "UEFI CA 2023 tõrge: none"
}

# 8. UEFICA2023ErrorEvent
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent –ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "UEFI CA 2023 tõrkesündmus: $uefica 2023ErrorEvent"
} püüdmine {
    $uefica 2023ErrorEvent = $null
    Write-Host "UEFI CA 2023 tõrkesündmus: pole saadaval"
}

# Registry: Device Attributes (7 väärtust: 9-15)

# 9. OEMManufacturerName
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName –ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([string]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName is empty" ("OEMManufacturerName is empty")
        $oemManufacturerName = "Tundmatu"
    }
    Write-Host "OEM-i tootja nimi: $oemManufacturerName"
} püüdmine {
    Write-Warning "OEMManufacturerName registrivõtit ei leitud või puudub juurdepääs"
    $oemManufacturerName = $null
    Write-Host "OEM-i tootja nimi: pole saadaval"
}

# 10. OEMModelSystemFamily
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily –ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([string]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily is empty" (OEMModelSystemFamily on tühi)
        $oemModelSystemFamily = "Tundmatu"
    }
    Write-Host "OEM-i mudeli süsteemipere: $oemModelSystemFamily"
} püüdmine {
    Write-Warning "OEMModelSystemFamily registrivõtit ei leitud või puudub juurdepääs"
    $oemModelSystemFamily = $null
    Write-Host "OEM-i mudeli süsteemipere: pole saadaval"
}

# 11. OEMModelNumber
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber –ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([string]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber on tühi"
        $oemModelNumber = "Tundmatu"
    }
    Write-Host "OEM-mudeli number: $oemModelNumber"
} püüdmine {
    Write-Warning "OEMModelNumber registrivõtit ei leitud või puudub juurdepääs"
    $oemModelNumber = $null
    Write-Host "OEM-i mudeli number: pole saadaval"
}

# 12. FirmwareVersion
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([string]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion is empty" (Püsivaraversioon on tühi)
        $firmwareVersion = "Tundmatu"
    }
    Write-Host "Püsivara versioon: $firmwareVersion"
} püüdmine {
    Write-Warning "FirmwareVersion registrivõtit ei leitud või puudub juurdepääs"
    $firmwareVersion = $null
    Write-Host "Püsivara versioon: pole saadaval"
}

# 13. FirmwareReleaseDate
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate –ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([string]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate is empty" (PüsivaraReleaseDate on tühi)
        $firmwareReleaseDate = "Tundmatu"
    }
    Write-Host "Püsivara väljaandmiskuupäev: $firmwareReleaseDate"
} püüdmine {
    Write-Warning "FirmwareReleaseDate registry key not found or inaccessible"
    $firmwareReleaseDate = $null
    Write-Host "Püsivara väljaandmiskuupäev: pole saadaval"
}

# 14. OSArchitecture
PS-i versioon: kõik | Haldus: ei | Süsteeminõuded: pole
proovige {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Proovige registri taandeid
        $regValue = Get-ItemProperty -Tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture –ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture'i ei saanud määratleda"
        $osArchitecture = "Tundmatu"
    }
    Write-Host "OS-i arhitektuur: $osArchitecture"
} püüdmine {
    Write-Warning "OSArchitecture toomisel ilmnes tõrge: $_"
    $osArchitecture = "Tundmatu"
    Write-Host "OS-i arhitektuur: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
PS-i versioon: kõik | Haldus: võib olla vajalik | Süsteeminõuded: pole
proovige {
    $regValue = Get-ItemProperty -tee "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Convert FILETIME to UTC DateTime – registris talletatakse REG_BINARY (bait[]) või REG_QWORD (pikk)
    if ($null -ne $canAttemptUpdateAfter) {
        proovige {
            if ($canAttemptUpdateAfter -is [bait[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter; 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -on [pikk]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } püüdmine {
            Write-Warning "CanAttemptUpdateAfter FILETIME'i ei saanud kuupäevaks DateTime teisendada"
        }
    }
    Write-Host "Võib proovida värskendamist pärast: $canAttemptUpdateAfter"
} püüdmine {
    Write-Warning "CanAttemptUpdateAfter registry key not found or inaccessible"
    $canAttemptUpdateAfter = $null
    Write-Host "Võib proovida värskendamist pärast: pole saadaval"
}

# Sündmuselogid: süsteemilogi (10 väärtust: 16-25)

# 16-25. Sündmuselogi päringud
# Sündmuse ID-sid:
# 1801 – värskendamine algatati, taaskäivitamine on nõutav
# 1808 – värskendamine on lõpule
viidud # 1795 – püsivara tagastas tõrke (hõive tõrkekood)
# 1796 – tõrge logituna tõrkekoodiga (hõivekood)
# 1800 – taaskäivitamine on vajalik (POLE viga – värskendamine jätkub pärast taaskäivitamist)
# 1802 – teadaolev püsivaraprobleem blokeeris värskenduse (hõiva KI_<number> SkipReasonist)
# 1803 – vastavat KEK-i värskendust ei leitud (OEM peab esitama PK allkirjastatud KEK-i)
# PS versioon: 3.0+ | Haldus: võib olla vajalik süsteemilogi | Süsteeminõuded: pole
proovige {
    # Päring kõigi asjakohaste Secure Booti sündmuste ID-dega
    $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 "Süsteemilogist ei leitud secure Booti sündmusi"
        $latestEventId = $null
        $bucketId = $null
        $confidence = $null
        $skipReasonKnownIssue = $null
        $event 1801Kogum = 0
        $event 1808Count = 0
        $event 1795Kogus = 0
        $event 1795ErrorCode = $null
        $event 1796Count = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Kogum = 0
        $missingKEK = $false
        Write-Host "Uusim sündmuse ID: pole saadaval"
        Write-Host "Salve ID: pole saadaval"
        Write-Host "Usaldus: pole saadaval"
        Write-Host "Sündmuse 1801 arv: 0"
        Write-Host "Sündmuse 1808 arv: 0"
    } else {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object – laskuv järjestus | Select-Object –esimene 1
        if ($null -eq $latestEvent) {
            Write-Warning "Uusimat sündmust ei saanud määratleda"
            $latestEventId = $null
            Write-Host "Uusim sündmuse ID: pole saadaval"
        } else {
            $latestEventId = $latestEvent.Id
            Write-Host "Uusim sündmuse ID: $latestEventId"
        }

        # 17. BucketID – ekstraktitud sündmusest 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trimmi()
                Write-Host "Salve ID: $bucketId"
            } else {
                Write-Warning "BucketId-d ei leitud sündmusesõnumist"
                $bucketId = $null
                Write-Host "Salve ID: sündmusest ei leitud"
            }
        } else {
            Write-Warning "Uusim sündmus või sõnum on nullväärtusega, ei saa ekstraktida BucketId-d"
            $bucketId = $null
            Write-Host "Salve ID: pole saadaval"
        }

        # 18. Usaldus – saadud sündmusest 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trimmi()
                Write-Host "Usaldus: $confidence"
            } else {
                Write-Warning "Sündmusesõnumist ei leitud usaldustaset"
                $confidence = $null
                Write-Host "Usaldus: sündmusest ei leitud"
            }
        } else {
            Write-Warning "Viimane sündmus või sõnum on nullväärtusega, ei saa ekstraktida usaldust"
            $confidence = $null
            Write-Host "Usaldus: pole saadaval"
        }

        # 18b. SkipReason – KI_<numbri> ekstraktimine SkipReasonist samal sündmusel nagu BucketId
        # See jäädvustab teadaolevad probleemi ID-d, mis kuvatakse bucketId/Confidence kõrval (mitte ainult sündmus 1802)
        $skipReasonKnownIssue = $null
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Sõnum) {
            if ($latestEvent.Message -match 'SkipReason:\s*(KI_\d+)') {
                $skipReasonKnownIssue = $matches[1]
                Write-Host "SkipReason Known Issue: $skipReasonKnownIssue" -ForegroundColor Yellow
            }
        }

        # 19. Sündmus1801Count
        $event 1801Array = @($events | Where-Object {$_. ID -eq 1801})
        $event 1801Count = $event 1801Array.Count
        Write-Host "Sündmuse 1801 arv: $event 1801Count"

        # 20. Sündmus1808Count
        $event 1808Array = @($events | Where-Object {$_. ID -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Sündmuse 1808 arv: $event 1808Count"
        
        # Lähtesta tõrkesündmuse muutujad
        $event 1795Count = 0
        $event 1795ErrorCode = $null
        $event 1796Count = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Konto = 0
        $missingKEK = $false
        
        # Kontrollige ainult tõrkesündmusi, kui värskendamine POLE lõpule viidud
        # Jäta tõrkeanalüüs vahele, kui: 1808 on uusim sündmus VÕI UEFICA2023Status on "Värskendatud"
        $updateComplete = ($latestEventId -eq 1808) -or ($uefica 2023Status -eq "Värskendatud")
        
        kui (-mitte $updateComplete) {
            Write-Host "Värskendamine pole lõpule viidud – veasündmuste otsimine..." – esiplaanivärvi kollane
            
            # 21. Sündmus1795 – püsivara tõrge (hõive tõrkekood)
            $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 –esimene 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 "Sündmuse 1795 (püsivara tõrge) arv: $event 1795Count" $(if ($event 1795ErrorCode) { "Kood: $event 1795ErrorCode" })
            }
            
            # 22. Sündmus1796 – logitud tõrkekood (hõive tõrkekood)
            $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 –esimene 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 "Sündmuse 1796 (tõrkelogitud) arv: $event 1796Count" $(if ($event 1796ErrorCode) { "Kood: $event 1796ErrorCode" })
            }
            
            # 23. Sündmus1800 – taaskäivitamine on nõutav (POLE tõrge – värskendamine jätkub pärast taaskäivitamist)
            $event 1800Array = @($events | Where-Object {$_. ID -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            if ($rebootPending) {
                Write-Host "Sündmus 1800 (taaskäivitamise ootel): värskendamine jätkub pärast taaskäivitamist" -ForegroundColor Cyan
            }
            
            # 24. Event1802 – teadaolev püsivara probleem (hõiva KI_<number> SkipReasonist)
            $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 –esimene 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Sündmuse 1802 (teadaolev püsivaraprobleem) arv: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Sündmus1803 – puuduv KEK-i värskendus (OEM peab esitama PK allkirjastatud KEK-i)
            $event 1803Array = @($events | Where-Object {$_. ID -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            if ($missingKEK) {
                Write-Host "Sündmus 1803 (puuduv KEK): OEM peab esitama PK allkirjastatud KEK-i" -Esiplaanivärvi kollane
            }
        } else {
            Write-Host "Värskendamine on lõpule viidud (sündmus 1808 või olek=värskendatud) – tõrkeanalüüsi vahelejätmine" –esiplaanivärvroheline
        }
    }
} püüdmine {
    Write-Warning "Sündmuselogide toomisel ilmnes tõrge. Võib vajada administraatoriõigusi: $_"
    $latestEventId = $null
    $bucketId = $null
    $confidence = $null
    $skipReasonKnownIssue = $null
    $event 1801Kogum = 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 1803Kogum = 0
    $missingKEK = $false
    Write-Host "Uusim sündmuse ID: tõrge"
    Write-Host "Salve ID: tõrge"
    Write-Host "Confidence: Error" (Usaldusväärsus: tõrge)
    Write-Host "Sündmuse 1801 arv: 0"
    Write-Host "Sündmuse 1808 arv: 0"
}

WMI-/CIM-päringute arv (5 väärtust)

# 26. OsVersion
# PS Versioon: 3.0+ (Get-WmiObject kasutamine versioonis 2.0) | Haldus: ei | Süsteeminõuded: pole
proovige {
    $osInfo = Get-CimInstance Win32_OperatingSystem –ErrorAction Stop
    if ($null -eq $osInfo -või [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "OS-i versiooni ei saanud tuua"
        $osVersion = "Tundmatu"
    } else {
        $osVersion = $osInfo.Version
    }
    Write-Host "OS-i versioon: $osVersion"
} püüdmine {
    # CIM võib mõnes keskkonnas nurjuda – kasutage taandefunktsiooni
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "OS-i versioon: $osVersion"
}

# 27. LastBootTime
# PS Versioon: 3.0+ (Get-WmiObject kasutamine versioonis 2.0) | Haldus: ei | Süsteeminõuded: pole
proovige {
    $osInfo = Get-CimInstance Win32_OperatingSystem –ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Viimast algkäivitusaega ei saanud tuua"
        $lastBootTime = $null
        Write-Host "Viimane algkäivitusaeg: pole saadaval"
    } else {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Viimane algkäivitusaeg: $lastBootTime"
    }
} püüdmine {
    # CIM võib mõnes keskkonnas nurjuda – kasutage taandefunktsiooni
    proovige {
        $lastBootTime = (Get-Process -ID 0 -ErrorAction SilentlyContinue). Alguskaeg
    } püüdmine {
        $lastBootTime = $null
    }
    kui ($lastBootTime) { Write-Host "Viimane algkäivitusaeg: $lastBootTime" } else { Write-Host "Viimane algkäivitusaeg: pole saadaval" }
}

# 28. BaseBoardManufacturer
# PS Versioon: 3.0+ (Get-WmiObject kasutamine versioonis 2.0) | Haldus: ei | Süsteeminõuded: pole
proovige {
    $baseBoard = Get-CimInstance Win32_BaseBoard –ErrorAction Stop
    if ($null -eq $baseBoard -või [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Baaslaua tootjat ei saanud tuua"
        $baseBoardManufacturer = "Tundmatu"
    } else {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Alusplaadi tootja: $baseBoardManufacturer"
} püüdmine {
    # CIM võib nurjuda – aluslaua teave on lisainfo
    $baseBoardManufacturer = "Tundmatu"
    Write-Host "Alusplaadi tootja: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS Versioon: 3.0+ (Get-WmiObject kasutamine versioonis 2.0) | Haldus: ei | Süsteeminõuded: pole
proovige {
    $baseBoard = Get-CimInstance Win32_BaseBoard –ErrorAction Stop
    if ($null -eq $baseBoard -või [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Baaslaua toodet ei saanud tuua"
        $baseBoardProduct = "Tundmatu"
    } else {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Baaslaua toode: $baseBoardProduct"
} püüdmine {
    # CIM võib nurjuda – aluslaua teave on lisainfo
    $baseBoardProduct = "Tundmatu"
    Write-Host "Baaslaua toode: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
PS-i versioon: kõik | Haldus: ei | Süsteeminõuded: ajastatud toiming on olemas
# Kontrollib, kas Secure-Boot-Update'i ajastatud toiming on lubatud
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Tundmatu"
proovige {
    $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' -or $taskData.Status -eq 'Töötab')
        }
    } else {
        $secureBootTaskStatus = "NotFound"
        $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
    }
} püüdmine {
    $secureBootTaskStatus = "Tõrge"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. WinCS-i võtme olek (F33E0C8E002 – turvaline algkäivitusserdi värskendus)
PS-i versioon: kõik | Haldus: Jah (päringu jaoks) | Süsteeminõuded: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Tundmatu"
proovige {
    # Kontrollige WinCsFlags.exe
levinumaid asukohti     $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p in $possiblePaths) {
        if (testtee $p) { $wincsFlagsPath = $p; break }
    }

    if ($wincsFlagsPath) {
        Päringukohane võti # – nõuab administraatoriõigusi
        $queryOutput = & $wincsFlagsPath /päring – võti F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Kontrollige, kas võti on rakendatud (otsige märksõna "Aktiivne konfiguratsioon" või sarnast näidikut)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Rakendatud"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            } elseif ($queryOutputStr -match "ei leitud|Konfiguratsioon puudub") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS Key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } else {
                # Võti on olemas – kontrollige, kas väljundis on olek
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Rakendatud"
                Write-Host "WinCS Key F33E0C8E002: Applied" -ForegroundColor Green
            }
        } else {
            # Otsi konkreetseid tõrketeateid
            if ($queryOutputStr -match "Juurdepääs keelatud|administraator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS Key F33E0C8E002: juurdepääs on keelatud (käivita administraatorina)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "ei leitud|Konfiguratsioon puudub") {
                $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
    }
} püüdmine {
    $wincsKeyStatus = "Tõrge"
    Write-Host "WinCS Key F33E0C8E002: Error checking - $_" -ForegroundColor Red
}              

# =============================================================================
# Parandustuvastus – olekuväljundi & väljumiskood
# =============================================================================

# Kõigi kogutud inventuuriandmete
järgu oleku objekt $status = [tellitud]@{
    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
    Usaldus = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<arv> sündmusest SkipReason sündmuses
BucketId     Sündmus1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Jäädvustatud üksikasjadega tõrkesündmused
    Event1795Count = $event 1795Count # Firmware returned error
    Event1795ErrorCode = $event 1795ErrorCode # Püsivara
tõrkekood     Event1796Count = $event 1796Count # Logitud
tõrkekood     Event1796ErrorCode = $event 1796ErrorCode # Captured error code
    Event1800Count = $event 1800Count # Vajalik taaskäivitamine (NOT tõrge)
    RebootPending = $rebootPending # Tõene, kui sündmus 1800 on olemas
    Event1802Count = $event 1802Count # teadaolev püsivara probleem
    KnownIssueId = $knownIssueId # KI_<> alates SkipReasonist
    Sündmus1803Count = $event 1803Count # KEK-i värskendus
on puudu     MissingKEK = $missingKEK # OEM peab esitama PK allkirjastatud KEK-i
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # Tõene, kui rakendatakse
F33E0C8E002 võti     WinCSKeyStatus = $wincsKeyStatus # Rakendatud, NotApplied, WinCsFlagsNotFound jne.
}

# Väljund olek – andmete koondamiseks
$jsonOutput = $status | ConvertTo-Json – tihendamine

# Kui OutputPath on saadaval, salvesta faili; muul juhul väljund stdout
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Valideeri OutputPath – jätke vahele, kui see näeb välja nagu spikritaotlus või kui sellel on sobimatud märgid
    if ($OutputPath -match ^[/\-]' -või $OutputPath -match '[<>:"|? *]') {
        Write-Host "Määratud on sobimatu OutputPath, väljastus stdout'i" –Esiplaanivärvi kollane
       
Write-Output $jsonOutput         if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") { exit 0 } else { exit 1 }
    }
    
    # Veenduge, et väljundkaust oleks olemas
    kui (-not (testtee $OutputPath)) {
        proovige {
            New-Item -ItemType'i kataloog -tee $OutputPath -Force | Nullväärtuseta
        } püüdmine {
            Write-Warning "Väljundkausta ei saanud luua: $OutputPath - $_"
        }
    }
    
    # Salvesta HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    proovige {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 –Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } püüdmine {
        Write-Warning "Faili ei saanud kirjutada: $outputFile - $_"
        # Naaske stdout'i
       
Write-Output $jsonOutput     }
} else {
    # Algne käitumine – väljund stdout
   
Write-Output $jsonOutput }

# Väljumiskood: "Värskendatud" on esitusraamatu
edukuse väärtus if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") {
    exit 0 # Without issue
} else {
    exit 1 # With issue
}