Drošās palaišanas inventarizācijas datu vākšanas skripta paraugs

<#
. KOPSAVILKUMS
    Nosaka drošās palaišanas sertifikāta atjaunināšanas statusu autoparka mēroga pārraudzībai.

. APRAKSTS
    Šis noteikšanas skripts apkopo drošas palaišanas statusu, sertifikātu atjaunināšanas reģistra vērtības,
    un ierīces informāciju. Tas izvada JSON virkni pārraudzībai un atskaišu izveidei.

    Saderīgs ar Intune koriģēšanu, uz GPO balstītu kolekciju un citiem pārvaldības rīkiem.
Nav nepieciešams labošanas skripts — tā ir tikai pārraudzība.

    Exit 0 = "Bez problēmas" (sertifikāti atjaunināti)
    1. izeja = "Ar izdošanu" (sertifikāti nav atjaunināti — tikai informatīvi)

. PARAMETER OutputPath
    Neobligāts. Ceļš uz mapi, kurā tiks saglabāts JSON fails.
Ja tas ir norādīts, saglabā HOSTNAME_latest.json šajā mapē.
Ja nav, izvada JSON uz stdout (sākotnējā darbība).

. PIEMĒRS
    # Izvade uz stdout (Intune/SCCM noteikšana)
    .\Detect-SecureBootCertUpdateStatus.ps1

. PIEMĒRS
    # Saglabāšana tīkla koplietojumā (GPO izvietošana)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. PIEZĪMES
    Reģistra ceļi uz 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
    NETIEŠI, TOSTARP, BET NEAPROBEŽOJOTIES AR GARANTIJĀM PAR PIEMĒROTĪBU PĀRDOŠANAI,
    PIEMĒROTĪBA NOTEIKTAM MĒRĶIM UN TIESĪBU NEPĀRKĀPŠANA. NEKĀDĀ GADĪJUMĀ
    AUTORI VAI AUTORTIESĪBU ĪPAŠNIEKI IR ATBILDĪGI PAR JEBKĀDĀM PRASĪBĀM, ZAUDĒJUMIEM VAI CITIEM
    ATBILDĪBA, NEATKARĪGI NO TĀ, VAI TĀ IR LĪGUMA, DELIKTA VAI CITA DARBĪBA, KAS IZRIET NO:
    ĀRPUS VAI SAISTĪBĀ AR PROGRAMMATŪRU VAI TĀS LIETOŠANU VAI CITIEM DARĪJUMIEM
    PROGRAMMATŪRA.
#>
parametrs(
    [Parametrs(obligāts = $false)]
    [virkne]$OutputPath
)

# Lejupielādēt URL: https://aka.ms/getsecureboot -> "Izvietošanas un pārraudzības paraugi"
# Piezīme. Šis skripts tiek izpildīts galapunktos, lai apkopotu drošās palaišanas statusa datus.

# 1. Resursdatora nosaukums
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $hostname = $env:COMPUTERNAME
    if ([virkne]::IsNullOrEmpty($hostname)) {
        Write-Warning "Nevarēja noteikt resursdatora nosaukumu"
        $hostname = "Nezināms"
    }
    Write-Host "Resursdatora nosaukums: $hostname"
} noķert {
    Write-Warning "Kļūda, izgūstot resursdatora nosaukumu: $_"
    $hostname = "Kļūda"
    Write-Host "Resursdatora nosaukums: $hostname"
}

# 2. Kolekcijas laiks
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $collectionTime = get-date
    IF ($null -eq $collectionTime) {
        Write-Warning "Nevarēja izgūt pašreizējo datumu/laiku"
        $collectionTime = "Nezināms"
    }
    Write-Host "Kolekcijas laiks: $collectionTime"
} noķert {
    Write-Warning "Kļūda, izgūstot datumu/laiku: $_"
    $collectionTime = "Kļūda"
    Write-Host "Kolekcijas laiks: $collectionTime"
}

# Reģistrs: drošas palaišanas galvenā atslēga (3 vērtības)

# 3. SecureBootEnabled
# PS versija: 3.0+ | Administrēšana: Var būt nepieciešams | Sistēmas prasības: UEFI/ar drošās palaišanas iespējota sistēma
Izmēģiniet {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Drošā palaišana iespējota: $secureBootEnabled"
} noķert {
    Write-Warning "Nevar noteikt drošās palaišanas statusu, izmantojot cmdlet: $_"
    # Izmēģiniet reģistra atkāpšanos
    Izmēģiniet {
        $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [būla vērtība]$regValue.UEFISecureBootEnabled
        Write-Host "Drošā palaišana iespējota: $secureBootEnabled"
    } noķert {
        Write-Warning "Nevar noteikt drošās palaišanas statusu, izmantojot reģistru. Iespējams, sistēma neatbalsta UEFI/drošo sāknēšanu."
        $secureBootEnabled = $null
        Write-Host "Drošā palaišana iespējota: nav pieejams"
    }
}

# 4. HighConfidenceOptOut
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Augstas ticamības atteikšanās: $highConfidenceOptOut"
} noķert {
    # HighConfidenceOptOut nav obligāts — tas nav pieejams lielākajā daļā sistēmu
    $highConfidenceOptOut = $null
    Write-Host "Augstas ticamības atteikšanās: nav iestatīta"
}

# 4b. MicrosoftUpdateManagedOptIn
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update pārvaldīta piekrišana: $microsoftUpdateManagedOptIn"
} noķert {
    # MicrosoftUpdateManagedOptIn ir neobligāts — tas nav pieejams lielākajā daļā sistēmu
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update pārvaldīta piekrišana: nav iestatīta"
}

# 5. Pieejamie atjauninājumi
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    ja ($null -ne $availableUpdates) {
        # Konvertēt heksadecimālajā formātā
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Pieejamie Atjauninājumi: $availableUpdatesHex"
    } citādi {
        Write-Host "Pieejams Atjauninājumi: nav pieejams"
    }
} noķert {
    Write-Warning "AvailableUpdates reģistra atslēga nav atrasta vai nav pieejama"
    $availableUpdates = $null
    Write-Host "Pieejams Atjauninājumi: nav pieejams"
}

# 5b. AvailableUpdatesPolicy (GPO kontrolēta pastāvīgā vērtība)
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    Ja ($null -ne $availableUpdatesPolicy) {
        # Konvertēt heksadecimālajā formātā
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Pieejamā Atjauninājumi politika: $availableUpdatesPolicyHex"
    } citādi {
        Write-Host "Pieejamā Atjauninājumi politika: nav iestatīta"
    }
} noķert {
    # AvailableUpdatesPolicy ir neobligāts — tiek iestatīts tikai tad, ja tiek lietots
GPO     $availableUpdatesPolicy = $null
    Write-Host "Pieejamā Atjauninājumi politika: nav iestatīta"
}

# Reģistrs: apkalpošanas atslēga (3 vērtības)

# 6. UEFICA2023Statuss
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 statuss: $uefica 2023Status"
} noķert {
    Write-Warning "Windows UEFI CA 2023 statusa reģistra atslēga nav atrasta vai nav pieejama"
    $uefica 2023Statuss = $null
    Write-Host "Windows UEFI CA 2023 statuss: nav pieejams"
}

# 7. UEFICA2023Kļūda
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Error = $regValue.UEFICA2023Error
    Write-Host "UEFI CA 2023 kļūda: $uefica 2023Error"
} noķert {
    # UEFICA2023Kļūda pastāv tikai tad, ja ir kļūda — prombūtne ir laba
    $uefica 2023Kļūda = $null
    Write-Host "UEFI CA 2023 kļūda: nav"
}

# 8. UEFICA2023ErrorEvent
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "UEFI CA 2023 kļūdas notikums: $uefica 2023ErrorEvent"
} noķert {
    $uefica 2023ErrorEvent = $null
    Write-Host "UEFI CA 2023 kļūdas notikums: nav pieejams"
}

# Reģistrs: ierīces atribūti (7 vērtības: 9-15)

# 9. OEMManufacturerName
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([virkne]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName is empty"
        $oemManufacturerName = "Nezināms"
    }
    Write-Host "OEM ražotāja nosaukums: $oemManufacturerName"
} noķert {
    Write-Warning "OEMManufacturerName reģistra atslēga nav atrasta vai nav pieejama"
    $oemManufacturerName = $null
    Write-Host "OEM ražotāja nosaukums: nav pieejams"
}

# 10. OEMModelSystemFamily
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([virkne]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily ir tukša"
        $oemModelSystemFamily = "Nezināms"
    }
    Write-Host "OEM modeļu sistēmu saime: $oemModelSystemFamily"
} noķert {
    Write-Warning "OEMModelSystemFamily reģistra atslēga nav atrasta vai nav pieejama"
    $oemModelSystemFamily = $null
    Write-Host "OEM modeļu sistēmu saime: nav pieejama"
}

# 11. OEMModelNumber
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([virkne]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber ir tukšs"
        $oemModelNumber = "Nezināms"
    }
    Write-Host "OEM modeļa numurs: $oemModelNumber"
} noķert {
    Write-Warning "OEMModelNumber reģistra atslēga nav atrasta vai nav pieejama"
    $oemModelNumber = $null
    Write-Host "OEM modeļa numurs: nav pieejams"
}

# 12. FirmwareVersion
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([virkne]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion ir tukša"
        $firmwareVersion = "Nezināms"
    }
    Write-Host "Aparātprogrammatūras versija: $firmwareVersion"
} noķert {
    Write-Warning "FirmwareVersion reģistra atslēga nav atrasta vai nav pieejama"
    $firmwareVersion = $null
    Write-Host "Aparātprogrammatūras versija: nav pieejama"
}

# 13. FirmwareReleaseDate
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([virkne]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate ir tukšs"
        $firmwareReleaseDate = "Nezināms"
    }
    Write-Host "Aparātprogrammatūras izlaišanas datums: $firmwareReleaseDate"
} noķert {
    Write-Warning "FirmwareReleaseDate reģistra atslēga nav atrasta vai nav pieejama"
    $firmwareReleaseDate = $null
    Write-Host "Aparātprogrammatūras izlaišanas datums: nav pieejams"
}

# 14. OSArchitecture
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([virkne]::IsNullOrEmpty($osArchitecture)) {
        # Izmēģiniet reģistra atkāpšanos
        $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([virkne]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture nevarēja noteikt"
        $osArchitecture = "Nezināms"
    }
    Write-Host "OS arhitektūra: $osArchitecture"
} noķert {
    Write-Warning "Kļūda, izgūstot OSArchitecture: $_"
    $osArchitecture = "Nezināms"
    Write-Host "OS arhitektūra: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS versija: Visi | Administrēšana: Var būt nepieciešams | Sistēmas prasības: nav
Izmēģiniet {
    $regValue = Get-ItemProperty -path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Convert FILETIME to UTC DateTime — registry stores as REG_BINARY (byte[]) or REG_QWORD (long)
    IF ($null -ne $canAttemptUpdateAfter) {
        Izmēģiniet {
            if ($canAttemptUpdateAfter -is [baits[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [garš]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } noķert {
            Write-Warning "Nevarēja konvertēt CanAttemptUpdateAfter FILETIME uz DateTime"
        }
    }
    Write-Host "Var mēģināt atjaunināt pēc: $canAttemptUpdateAfter"
} noķert {
    Write-Warning "CanAttemptUpdateAfter registry key not found or inaccessible"
    $canAttemptUpdateAfter = $null
    Write-Host "Var mēģināt atjaunināt pēc: nav pieejams"
}

# Notikumu žurnāli: sistēmas žurnāls (10 vērtības: 16-25)

# 16-25. Notikumu žurnāla vaicājumi
# Notikuma ID:
# 1801 — sākta atjaunināšana, nepieciešama
atkārtota palaišana # 1808 — atjaunināšana sekmīgi
pabeigta # 1795 — aparātprogrammatūras atgrieztā kļūda (tveršanas kļūdas kods)
# 1796 — kļūda, kas reģistrēta ar kļūdas kodu (tveršanas kodu)
# 1800 - nepieciešama atsāknēšana (NAV kļūda - atjaunināšana turpināsies pēc restartēšanas)
# 1802 — zināma aparātprogrammatūras problēma bloķēja atjaunināšanu (tver KI_<numura> no SkipReason)
# 1803 — nav atrasts atbilstošais KEK atjauninājums (OEM ir jānodrošina PK parakstīts KEK)
# PS versija: 3.0+ | Administrēšana: var būt nepieciešams sistēmas žurnālam | Sistēmas prasības: nav
Izmēģiniet {
    # Vaicāt visus atbilstošos
drošās palaišanas notikuma ID     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='Sistēma'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    Ja ($events. Count -eq 0) {
        Write-Warning "Sistēmas žurnālā nav atrasts neviens drošas palaišanas notikums"
        $latestEventId = $null
        $bucketId = $null
        $confidence = $null
        $skipReasonKnownIssue = $null
        $event 1801Count = 0
        $event 1808Count = 0
        $event 1795Skaits = 0
        $event 1795ErrorCode = $null
        $event 1796Skaits = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Count = 0
        $missingKEK = $false
        Write-Host "Jaunākā notikuma ID: nav pieejams"
        Write-Host "Intervāla ID: nav pieejams"
        Write-Host "Uzticamība: nav pieejama"
        Write-Host "Notikumu 1801 skaits: 0"
        Write-Host "Notikumu 1808 skaits: 0"
    } citādi {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated — dilstošā secībā | Select-Object -Pirmais 1
        IF ($null -EQ $latestEvent) {
            Write-Warning "Nevarēja noteikt jaunāko notikumu"
            $latestEventId = $null
            Write-Host "Jaunākā notikuma ID: nav pieejams"
        } citādi {
            $latestEventId = latestEvent.Id
USD             Write-Host "Jaunākā notikuma ID: $latestEventId"
        }

        # 17. BucketID — izvilkts no notikuma 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trim()
                Write-Host "Intervāla ID: $bucketId"
            } citādi {
                Write-Warning "BucketId nav atrasts notikuma ziņojumā"
                $bucketId = $null
                Write-Host "Intervāla ID: notikumā nav atrasts"
            }
        } citādi {
            Write-Warning "Jaunākais notikums vai ziņojums ir null, nevar izvilkt BucketId"
            $bucketId = $null
            Write-Host "Kopuma ID: nav pieejams"
        }

        # 18. Uzticība - iegūts no notikuma 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trim()
                Write-Host "Pārliecība: $confidence"
            } citādi {
                Write-Warning "Ticamības līmenis nav atrasts notikuma ziņojumā"
                $confidence = $null
                Write-Host "Uzticamība: notikumā nav atrasta"
            }
        } citādi {
            Write-Warning "Jaunākais notikums vai ziņojums ir nulle, nevar iegūt pārliecību"
            $confidence = $null
            Write-Host "Uzticamība: nav pieejama"
        }

        # 18b. SkipReason — izvelk KI_<skaitli> no SkipReason tajā pašā notikumā kā BucketId
        # Tas tver zināmo problēmu ID, kas tiek parādīti kopā ar BucketId/Confidence (ne tikai notikumu 1802)
        $skipReasonKnownIssue = $null
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'SkipReason:\s*(KI_\d+)') {
                $skipReasonKnownIssue = $matches[1]
                Write-Host "SkipReason zināma problēma: $skipReasonKnownIssue" -ForegroundColor dzeltena
            }
        }

        # 19. Event1801Count
        $event 1801Array = @($events | Where-Object {$_. ID -eq 1801})
        $event 1801Count = $event 1801Array.Count
        Write-Host "Notikumu skaits 1801: $event 1801Count"

        # 20. Event1808Count
        $event 1808Array = @($events | Where-Object {$_. ID -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Event 1808 Count: $event 1808Count"
        
        # Inicializēt kļūdas notikumu mainīgos
        $event 1795Skaits = 0
        $event 1795ErrorCode = $null
        $event 1796Skaits = 0
        $event 1796ErrorCode = $null
        $event 1800Count = 0
        $rebootPending = $false
        $event 1802Count = 0
        $knownIssueId = $null
        $event 1803Skaits = 0
        $missingKEK = $false
        
        # Kļūdu notikumu pārbaude tikai tad, ja atjaunināšana NAV pabeigta
        # Izlaist kļūdu analīzi, ja: 1808 ir jaunākais notikums VAI UEFICA2023Statuss ir "Atjaunināts"
        $updateComplete = ($latestEventId -eq 1808) -or ($uefica 2023Status -eq "Atjaunināts")
        
        Ja (-not $updateComplete) {
            Write-Host "Atjaunināšana nav pabeigta — tiek pārbaudīts, vai nav kļūdu notikumu..." -ForegroundColor dzeltena
            
            # 21. Event1795 — aparātprogrammatūras kļūda (tveršanas kļūdas kods)
            $event 1795Masīvs = @($events | Where-Object {$_. ID -eq 1795})
            $event 1795Count = $event 1795Array.Count
            ja ($event 1795Count -gt; 0) {
                $latestEvent 1795 = $event 1795Masīvs | Sort-Object TimeCreated — dilstošā secībā | Select-Object -Pirmais 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 "Notikumu 1795 (aparātprogrammatūras kļūda) Count: $event 1795Count" $(if ($event 1795ErrorCode) { "Code: $event 1795ErrorCode" })
            }
            
            # 22. Event1796 — reģistrētais kļūdas kods (tveršanas kļūdas kods)
            $event 1796Masīvs = @($events | Where-Object {$_. ID -eq 1796})
            $event 1796Count = $event 1796Array.Count
            ja ($event 1796Count -gt; 0) {
                $latestEvent 1796 = $event 1796Masīvs | Sort-Object TimeCreated — dilstošā secībā | Select-Object -Pirmais 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 "Notikumu 1796 (kļūdu reģistrēts) skaits: $event 1796Count" $(if ($event 1796ErrorCode) { "Kods: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 — nepieciešama atkārtota palaišana (NAV kļūda – atjaunināšana tiks turpināta pēc atkārtotas palaišanas)
            $event 1800Array = @($events | Where-Object {$_. ID -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt; 0
            Ja ($rebootPending) {
                Write-Host "Notikums 1800 (gaida atkārtotu palaišanu): atjaunināšana turpināsies pēc atkārtotas palaišanas" -ForegroundColor Cyan
            }
            
            # 24. Event1802 — zināma aparātprogrammatūras problēma (tveršana KI_<numura> no SkipReason)
            $event 1802Array = @($events | Where-Object {$_. ID -eq 1802})
            $event 1802Count = $event 1802Array.Count
            ja ($event 1802Count, -gt; 0) {
                $latestEvent 1802 = $event 1802Masīvs | Sort-Object TimeCreated — dilstošā secībā | Select-Object -Pirmais 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Notikums 1802 (zināma aparātprogrammatūras problēma) Skaits: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 — trūkst KEK atjauninājuma (OEM ir jānodrošina PK parakstīts KEK)
            $event 1803Array = @($events | Where-Object {$_. ID -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt; 0
            Ja ($missingKEK) {
                Write-Host "Notikums 1803 (trūkst KEK): OEM jānodrošina PK parakstīts KEK" -ForeplanColor Yellow
            }
        } citādi {
            Write-Host "Atjaunināšana pabeigta (notikums 1808 vai Status=Atjaunināts) — tiek izlaista kļūdu analīze" -ForegroundColor Green
        }
    }
} noķert {
    Write-Warning "Kļūda, izgūstot notikumu žurnālus. Var būt nepieciešamas administratora tiesības: $_"
    $latestEventId = $null
    $bucketId = $null
    $confidence = $null
    $skipReasonKnownIssue = $null
    $event 1801Count = 0
    $event 1808Count = 0
    $event 1795Skaits = 0
    $event 1795ErrorCode = $null
    $event 1796Skaits = 0
    $event 1796ErrorCode = $null
    $event 1800Count = 0
    $rebootPending = $false
    $event 1802Count = 0
    $knownIssueId = $null
    $event 1803Skaits = 0
    $missingKEK = $false
    Write-Host "Jaunākā notikuma ID: kļūda"
    Write-Host "Bucket ID: Error"
    Write-Host "Confidence: Error" (Uzticamība: kļūda)
    Write-Host "Notikumu 1801 skaits: 0"
    Write-Host "Notikumu 1808 skaits: 0"
}

# WMI/CIM vaicājumi (5 vērtības)

# 26. OSVersion
# PS versija: 3.0+ (izmantojiet Get-WmiObject 2.0) | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [virkne]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nevarēja izgūt operētājsistēmas versiju"
        $osVersion = "Nezināms"
    } citādi {
        $osVersion = $osInfo.Version
    }
    Write-Host "Operētājsistēmas versija: $osVersion"
} noķert {
    # CIM var neizdoties dažās vidēs — izmantojiet atkāpšanos
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([virkne]::IsNullOrEmpty($osVersion)) { $osVersion = "Nezināms" }
    Write-Host "Operētājsistēmas versija: $osVersion"
}

# 27. LastBootTime
# PS versija: 3.0+ (izmantojiet Get-WmiObject 2.0) | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Nevarēja izgūt pēdējo sāknēšanas laiku"
        $lastBootTime = $null
        Write-Host "Pēdējās palaišanas laiks: nav pieejams"
    } citādi {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Pēdējās palaišanas laiks: $lastBootTime"
    }
} noķert {
    # CIM var neizdoties dažās vidēs — izmantojiet atkāpšanos
    Izmēģiniet {
        $lastBootTime = (Get-Process -ID 0 -ErrorAction SilentlyContinue). Sākuma laiks
    } noķert {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Pēdējās palaišanas laiks: $lastBootTime" } else { Write-Host "Pēdējās palaišanas laiks: nav pieejams" }
}

# 28. BaseBoardManufacturer
# PS versija: 3.0+ (izmantojiet Get-WmiObject 2.0) | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [virkne]::IsNullOrEmpty($baseBoard.Ražotājs)) {
        Write-Warning "Nevarēja izgūt grīdplates ražotāju"
        $baseBoardManufacturer = "Nezināms"
    } citādi {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Grīdlīstes ražotājs: $baseBoardManufacturer"
} noķert {
    # CIM var neizdoties - pamatplates informācija ir papildu
    $baseBoardManufacturer = "Nezināms"
    Write-Host "Grīdlīstes ražotājs: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS versija: 3.0+ (izmantojiet Get-WmiObject 2.0) | Administrēšana: Nē | Sistēmas prasības: nav
Izmēģiniet {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [virkne]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nevarēja izgūt grīdlīstes izstrādājumu"
        $baseBoardProduct = "Nezināms"
    } citādi {
        $baseBoardProduct = $baseBoard.Produkts
    }
    Write-Host "Grīdlīstes izstrādājums: $baseBoardProduct"
} noķert {
    # CIM var neizdoties - pamatplates informācija ir papildu
    $baseBoardProduct = "Nezināms"
    Write-Host "Grīdlīstes izstrādājums: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: Ieplānotais uzdevums pastāv
# Pārbauda, vai ir iespējots
ieplānotais drošās palaišanas atjaunināšanas uzdevums. $secureBootTaskEnabled = $null
$secureBootTaskStatus = "Nezināms"
Izmēģiniet {
    $taskOutput = schtasks.exe /query /tn "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    IF ($LASTEXITCODE -EQ 0) {
        $taskData = $taskOutput | ConvertFrom-CSV
        Ja ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Gatavs' vai $taskData.Status -eq 'Darbojas')
        }
    } citādi {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    Ja ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot atjaunināšanas uzdevums: $secureBootTaskStatus (iespējots: $secureBootTaskEnabled)" -ForegroundColor Yellow
    } citādi {
        Write-Host "SecureBoot atjaunināšanas uzdevums: $secureBootTaskStatus (iespējots: $secureBootTaskEnabled)" -ForegroundColor Green
    }
} noķert {
    $secureBootTaskStatus = "Kļūda"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot atjaunināšanas uzdevums: kļūdu pārbaude - $_" -ForegroundColor Red
}

# 31. WinCS atslēgas statuss (F33E0C8E002 — drošās palaišanas sertifikāta atjauninājums)
# PS versija: Visi | Administrēšana: Jā (vaicājumam) | Sistēmas prasības: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Nezināms"
Izmēģiniet {
    # Pārbaudiet kopējās atrašanās vietas WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p $possiblePaths) {
        if (testa ceļš $p) { $wincsFlagsPath = $p; pārtraukums }
    }

    Ja ($wincsFlagsPath) {
        # Vaicājumam specifiska atslēga — nepieciešamas administratora tiesības
        $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        IF ($LASTEXITCODE -EQ 0) {
            # Pārbaudiet, vai tiek lietots taustiņš (meklējiet "Aktīvā konfigurācija" vai līdzīgu indikatoru)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Applied"
                Write-Host "WinCS atslēga F33E0C8E002: lietota" -ForegroundColor Green
            } elseif ($queryOutputStr -match "nav atrasts|Nav konfigurācijas") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS atslēga F33E0C8E002: nav lietota" -ForegroundColor dzeltena
            } citādi {
                # Atslēga pastāv - pārbaudiet izvadi stāvoklim
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Lietots"
                Write-Host "WinCS atslēga F33E0C8E002: lietota" -ForeplanColor Green
            }
        } citādi {
            # Pārbaudiet, vai nav konkrētu kļūdu ziņojumu
            if ($queryOutputStr -match "Piekļuve liegta|administrators") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS atslēga F33E0C8E002: piekļuve liegta (palaist kā administratoram)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "nav atrasts|Nav konfigurācijas") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS atslēga F33E0C8E002: nav lietota" -ForegroundColor dzeltena
            } citādi {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "WinCS atslēga F33E0C8E002: vaicājums neizdevās" -ForegroundColor Red
            }
        }
    } citādi {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS atslēga F33E0C8E002: WinCsFlags.exe nav atrasta" -ForegroundColor Grey
    }
} noķert {
    $wincsKeyStatus = "Kļūda"
    Write-Host "WinCS atslēga F33E0C8E002: kļūdu pārbaude - $_" -ForegroundColor Red
}              

# =============================================================================
# Labošanas noteikšana — statusa izvade & izejas kods
# =============================================================================

# Būvējuma statusa objekts no visiem savāktajiem krājumu datiem
$status = [pasūtīts]@{
    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 }
    Resursdatora nosaukums = $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
    Uzticamība = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<skaitlis> no SkipReason notikumā
BucketId     Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Kļūdu notikumi ar tverto informāciju
    Event1795Count = $event 1795Count # aparātprogrammatūras atgriezta kļūda
    Event1795ErrorCode = $event 1795ErrorCode # kļūdas kods no aparātprogrammatūras
    Event1796Count = $event 1796Count # Reģistrētais kļūdas kods
    Event1796ErrorCode = $event 1796ErrorCode # tvertais kļūdas kods
    Event1800Count = $event 1800Count # Nepieciešama atkārtota palaišana (NAV kļūda)
    RebootPending = $rebootPending # True, ja notikums 1800 ir klāt
    Event1802Count = $event 1802Count # zināmā aparātprogrammatūras problēma
    KnownIssueId = $knownIssueId # KI_<skaitlis> no SkipReason
    Event1803Count = $event 1803Count # Trūkst KEK atjauninājuma
    MissingKEK = $missingKEK # OEM nepieciešams piegādāt PK parakstītu KEK
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True F33E0C8E002 ja tiek lietota
atslēga     WinCSKeyStatus = $wincsKeyStatus # applied, NotApplied, WinCsFlagsNotFound utt.
}

# Izvadiet statusu - datu apkopošanai
$jsonOutput = $status | ConvertTo-Json — saspiešana

# Ja OutputPath nodrošināts, saglabāt failā; Pretējā gadījumā izvade uz stdout
if (-not [virkne]::IsNullOrEmpty($OutputPath)) {
    # Validēt OutputPath — izlaidiet, ja tas izskatās pēc palīdzības pieprasījuma vai tam ir nederīgas rakstzīmes
    if ($OutputPath -match '^[/\-]' -or $OutputPath -match '[<>:"|? *]') {
        Write-Host "Norādīts nederīgs izvades ceļš, izeja uz stdout" -ForegroundColor Yellow
        Write-Output $jsonOutput
        if ($secureBootEnabled -and $uefica 2023Status -eq "Atjaunināts") { exit 0 } else { exit 1 }
    }
    
    # Pārliecinieties, vai izvades mape pastāv
    if (-not (testa ceļš $OutputPath)) {
        Izmēģiniet {
            New-Item -ItemType Directory -Path $OutputPath -Force | Out-Null
        } noķert {
            Write-Warning "Nevarēja izveidot izvades mapi: $OutputPath - $_"
        }
    }
    
    # Saglabāt HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    Izmēģiniet {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForeplanColor Green
    } noķert {
        Write-Warning "Nevarēja rakstīt failā: $outputFile - $_"
        # Atgriezties pie stdout
        Write-Output $jsonOutput
    }
} citādi {
    # Sākotnējā uzvedība - izvade uz stdout
    Write-Output $jsonOutput
}

# Izejas kods: "Atjaunināts" ir panākumu vērtība saskaņā ar rokasgrāmatu
ja ($secureBootEnabled -and $uefica 2023Status -eq "Atjaunināts") {
    iziet 0 # Bez problēmām
} citādi {
    exit 1 # Ar problēmu
}