Drošas sāknēšanas krājumu datu kolekcijas skripta paraugs

<#
. SYNOPSIS
    Nosaka drošas sāknēšanas sertifikāta atjaunināšanas statusu rūpīgai pārraudzībai.

. APRAKSTS
    Šis noteikšanas skripts apkopo drošās sāknēšanas statusu, sertifikāta atjaunināšanas reģistra vērtības,
    un ierīces informāciju. JSON virkne tiek izvadīta pārraudzībai un pārskatu veidošanai.

    Saderīgas Intune ar koriģēšanu, GPO kolekcijām un citiem pārvaldības rīkiem.
Nav jāveic labošanas skripts — tā tiek pārraudzīta tikai.

    Iziet 0 = "Bez problēmas" (sertifikāti ir atjaunināti)
    1. iziešana = "Ar problēmu" (sertifikāti nav atjaunināti — tikai informaīvs)

. PARAMETER OutputPath
    Neobligāts. Ceļš uz mapi, kurā tiks saglabāts JSON fails.
Ja nepieciešams, saglabā HOSTNAME_latest.json šajā mapē.
Ja tā nav nodrošināta, izvade no JSON uz izdaiļu (sākotnējā darbība).

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

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

. PIEZĪMES
    Reģistra ceļi katrai 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
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FIZISKĀ SAGATAVOTĪBA NOTEIKTAM MĒRĶIM UN NONINFRINGEMENT. JEBKURĀ GADĪJUMĀ
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    ĀRPUS PROGRAMMATŪRAS VAI SAISTĪBĀ AR TO, VAI PAR IZMANTOŠANU VAI CITIEM
DARĪJUMIEM     PROGRAMMATŪRA.
#>
param(
    [Parameter(Mandatory = $false)]
    [string]$OutputPath
)

# Download URL: https://aka.ms/getsecureboot -> "Deployment and monitoring Samples"
# Piezīme. Šis skripts darbojas galapunktos, lai apkopotu drošās sāknēšanas statusa datus.

# 1. Resursdatora nosaukums
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $hostname = $env:DATORA_NOSAUKUMS
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Resursdatora nosaukumu nevarēja noteikt"
        $hostname = "Nezināms"
    }
    Write-Host "Resursdatora nosaukums: $hostname"
} tvert {
    Write-Warning "Kļūda, izgūstot resursdatora nosaukumu: $_"
    $hostname = "Kļūda"
    Write-Host "Resursdatora nosaukums: $hostname"
}

# 2. CollectionTime
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $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"
} tvert {
    Write-Warning "Kļūda, izgūstot datumu/laiku: $_"
    $collectionTime = "Kļūda"
    Write-Host "Kolekcijas laiks: $collectionTime"
}

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

# 3. SecureBootEnabled
# PS versija: 3.0+ | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: sistēma ar UEFI/drošo sāknēšanas sistēmu
izmēģināt {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Droša palaišana iespējota: $secureBootEnabled"
} tvert {
    Write-Warning "Nevar noteikt drošās sāknēšanas statusu, izmantojot cmdlet: $_"
    # Try registry fallback
    izmēģināt {
        $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ša sāknēšana: iespējota: $secureBootEnabled"
    } tvert {
        Write-Warning "Nevar noteikt drošās sāknēšanas statusu, izmantojot reģistru. Sistēma, iespējams, neatbalsta UEFI/Secure Boot."
        $secureBootEnabled = $null
        Write-Host "Droša sāknēšana iespējota: nav pieejama"
    }
}

# 4. HighConfidenceOptOut
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $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"
} tvert {
    # HighConfidenceOptOut nav obligāta — nav pieejama vairākumā 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 jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed Opt In: $microsoftUpdateManagedOptIn" (Microsoft Update pārvaldīta pieteikšanās: $microsoftUpdateManagedOptIn)
} tvert {
    # MicrosoftUpdateManagedOptIn nav obligāti — nav pieejams vairākumā sistēmu
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed Opt In: Not Set"
}

# 5. AvailableUpdates
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Pārvēršana heksadecimālā formātā
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Pieejamās Atjauninājumi: $availableUpdatesHex"
    } vēl {
        Write-Host "Pieejamie Atjauninājumi: nav pieejams"
    }
} tvert {
    Write-Warning "AvailableUpdates registry key not found or inaccessible"
    $availableUpdates = $null
    Write-Host "Pieejamie Atjauninājumi: nav pieejams"
}

# 5b. AvailableUpdatesPolicy (GPO-controlled persistent value)
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Pārvēršana heksadecimālā formātā
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Pieejamā Atjauninājumi politika: $availableUpdatesPolicyHex"
    } vēl {
        Write-Host "Pieejamā Atjauninājumi politika: nav iestatīta"
    }
} tvert {
    # AvailableUpdatesPolicy nav obligāta — 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. UEFICA2023Status
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $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"
} tvert {
    Write-Warning "Windows UEFI CA 2023 statusa reģistra atslēga nav atrasta vai nav pieejama"
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 statuss: nav pieejams"
}

# 7. UEFICA2023Error
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $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"
} tvert {
    # UEFICA2023Error pastāv tikai tad, ja ir radusies kļūda — prombūtne ir laba
    $uefica 2023Error = $null
    Write-Host "UEFI CA 2023 kļūda: nav"
}

# 8. UEFICA2023ErrorEvent
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $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"
} tvert {
    $uefica 2023ErrorEvent = $null
    Write-Host "UEFI CA 2023 Error Event: Not Available"
}

# Registry: Device Attributes (7 values: 9-15)

# 9. OEMManufacturerName
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturName
    if ([string]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName is empty" (OEMManufacturerName ir tukšs)
        $oemManufacturerName = "Unknown"
    }
    Write-Host "OEM ražotāja nosaukums: $oemManufacturerName"
} tvert {
    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 jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([string]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily is empty" (OEMModelSystemFamily ir tukšs)
        $oemModelSystemFamily = "Nezināms"
    }
    Write-Host "OEM Model System Family: $oemModelSystemFamily"
} tvert {
    Write-Warning "OEMModelSystemFamily reģistra atslēga nav atrasta vai nav pieejama"
    $oemModelSystemFamily = $null
    Write-Host "OEM model system family: Not Available" (OEM modeļu sistēmas saime: nav pieejams)
}

# 11. OEMModelNumber
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([string]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber is empty" (OEMModelNumber ir tukšs)
        $oemModelNumber = "Nezināms"
    }
    Write-Host "OEM modeļa numurs: $oemModelNumber"
} tvert {
    Write-Warning "OEMModelNumber reģistra atslēga nav atrasta vai nav pieejama"
    $oemModelNumber = $null
    Write-Host "OEM modeļa numurs: nav pieejams"
}

# 12. AparātprogrammatūraVersija
# PS versija: Visi | Administrēšana: var būt jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.AparātprogrammatūraVersija
    if ([string]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "AparātprogrammatūraVersija ir tukša"
        $firmwareVersion = "Nezināms"
    }
    Write-Host "Aparātprogrammatūras versija: $firmwareVersion"
} tvert {
    Write-Warning "Aparātprogrammatūras_versijas 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 jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([string]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate is empty" (AparātprogrammatūrasreleaseDate ir tukšs)
        $firmwareReleaseDate = "Nezināms"
    }
    Write-Host "Aparātprogrammatūras izlaides datums: $firmwareReleaseDate"
} tvert {
    Write-Warning "FirmwareReleaseDate reģistra atslēga nav atrasta vai nav pieejama"
    $firmwareReleaseDate = $null
    Write-Host "Aparātprogrammatūras izlaides datums: nav pieejams"
}

# 14. OSArchitecture
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Try registry fallback
        $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture nevarēja noteikt"
        $osArchitecture = "Nezināms"
    }
    Write-Host "OS arhitektūra: $osArchitecture"
} tvert {
    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 jānorāda obligāti | Sistēmas prasības: Nav
izmēģināt {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Konvertējiet FILETIME uz UTC DateTime — reģistra REG_BINARY (baits[]) vai REG_QWORD (garš)
    if ($null -ne $canAttemptUpdateAfter) {
        izmēģināt {
            if ($canAttemptUpdateAfter -is [byte[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -ir [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } tvert {
            Write-Warning "CanAttemptUpdateAfter FILETIME uz DateTime"
        }
    }
    Write-Host "Var mēģināt atjaunināt pēc: $canAttemptUpdateAfter"
} tvert {
    Write-Warning "CanAttemptUpdateAfter reģistra atslēga nav atrasta vai nav pieejama"
    $canAttemptUpdateAfter = $null
    Write-Host "Var mēģināt veikt atjaunināšanu 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ākts atjauninājums, nepieciešama atkārtota palaišana
# 1808 — atjaunināšana pabeigta sekmīgi
# 1795 — aparātprogrammatūras atgrieztā kļūda (tveršanas kļūdas kods)
# 1796 - Kļūda, kas reģistrēta ar kļūdas kodu (tvert kodu)
# 1800 — nepieciešama atsāknēšana (NOT kļūda — atjaunināšana notiks pēc atsāknēšanas)
# 1802 - Zināma aparātprogrammatūras problēma: bloķēts atjauninājums (KI_<skaitļa> no SkipReason)
# 1803 — nav atrasts atbilstošs KEK atjauninājums (OEM ir nepieciešams nodrošināt PK parakstītu KEK)
# PS versija: 3.0+ | Administrēšana: Sistēmas žurnālam var būt nepieciešams obligāti obligāti | Sistēmas prasības: Nav
izmēģināt {
    # Vaicājums visiem atbilstošajiem drošās sāknēšanas
notikuma ID     $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 "Sistēmas žurnālā nav atrasts neviens drošas sāknēšanas notikums"
        $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 "Jaunākā notikuma ID: nav pieejams"
        Write-Host "Intervāla ID: nav pieejams"
        Write-Host "ticamības: nav pieejams"
        Write-Host "Pasākuma 1801 skaits: 0"
        Write-Host "Pasākuma 1808 skaits: 0"
    } vēl {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated -Descending | Select-Object -pirmais 1
        if ($null -eq $latestEvent) {
            Write-Warning "Nevarēja noteikt jaunāko notikumu"
            $latestEventId = $null
            Write-Host "Jaunākais notikuma ID: nav pieejams"
        } vēl {
            $latestEventId = $latestEvent.Id
            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"
            } vēl {
                Write-Warning ziņojums "BucketId nav atrasts notikuma ziņojumā"
                $bucketId = $null
                Write-Host "Intervāla ID: nav atrasts notikumā"
            }
        } vēl {
            Write-Warning "Jaunākais notikums vai ziņojums ir null, nevar izvilkt BucketId"
            $bucketId = $null
            Write-Host "Intervāla ID: nav pieejams"
        }

        # 18. Ticamības — izvilkta 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 "Uzticamība: $confidence"
            } vēl {
                Write-Warning "Ticamības līmenis nav atrasts notikuma ziņojumā"
                $confidence = $null
                Write-Host "ticamības: nav atrasts notikumā"
            }
        } vēl {
            Write-Warning "Jaunākais notikums vai ziņojums ir null, nevar izvilkt pārliecību"
            $confidence = $null
            Write-Host "ticamības: nav pieejams"
        }

        # 18b. SkipReason — KI_<skaitļa> no SkipReason tajā pašā gadījumā, kad BucketId
        # Tiek tverti zināmās problēmas ID, kas parādās kopā ar BucketId/Confidence (ne tikai Notikums 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 known issue: $skipReasonKnownIssue" -ForegroundColor Yellow
            }
        }

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

        # 20. Event1808Count
        $event 1808Array = @($events | Where-Object {$_. Id -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Notikuma 1808 count: $event 1808Count"
        
        # Inicializēšanas kļūdas notikuma mainīgie
        $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
        
        # Pārbaudīt, vai nav kļūdu notikumu, ja atjaunināšana NAV pabeigta
        # Izlaidiet kļūdu analīzi, ja: 1808 ir jaunākais notikums OR UEFICA2023Status ir "Atjaunināts"
        $updateComplete = ($latestEventId -eq 1808) - vai ($uefica 2023Status -eq "Atjaunināts")
        
        if (-not $updateComplete) {
            Write-Host "Atjaunināšana nav pabeigta — pārbauda, vai nav kļūdu notikumu..." -PriekšplānaColor dzeltena
            
            # 21. Notikums1795 — aparātprogrammatūras kļūda (tveršanas kļūdas kods)
            $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 -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 "Event 1795 (aparātprogrammatūras kļūda) count: $event 1795Count" $(if ($event 1795ErrorCode) { "Kods: $event 1795ErrorCode" })
            }
            
            # 22. Event1796 — reģistrēta kļūdas kods (tvert kļūdas kodu)
            $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 -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 "Event 1796 (Error Logged) Count: $event 1796Count" $(if ($event 1796ErrorCode) { "Code: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 — nepieciešama atsāknēšana (NAV kļūda — atjaunināšana notiks pēc atsāknēšanas)
            $event 1800Array = @($events | Where-Object {$_. Id -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            if ($rebootPending) {
                Write-Host "Event 1800 (Tiek atkārtota palaišana gaida): Pēc atkārtotas palaišanas tiek turpināts atjauninājums" -ForegroundColor Cyan
            }
            
            # 24. Notikums1802 — zināma aparātprogrammatūras problēma (KI_<izlaist> no SkipReason)
            $event 1802Array = @($events | Where-Object {$_. Id -eq 1802})
            $event 1802Count = $event 1802Array.Count
            if ($event 1802Count -gt 0) {
                $latestEvent 1802 = $event 1802Array | Sort-Object TimeCreated -Descending | Select-Object -pirmais 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Event 1802 (zināmā aparātprogrammatūras problēma) count: $event 1802Count" $(if ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 — trūkst kek atjauninājuma (OEM ir nepieciešams nodrošināt PK parakstītu KEK)
            $event 1803Array = @($events | Where-Object {$_. Id -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            if ($missingKEK) {
                Write-Host "Event 1803 (Missing KEK): OEM nepieciešams nodrošināt PK parakstītu KEK" -ForegroundColor Yellow
            }
        } vēl {
            Write-Host "Atjaunināšana pabeigta (Notikums 1808 vai Statuss=Atjaunināts) — kļūdu analīze" -PriekšplānsKrāsu krāsa zaļa
        }
    }
} tvert {
    Write-Warning "Kļūda, izgūstot notikumu žurnālus. Var būt nepieciešamas administratora privilēģijas: $_"
    $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 "Jaunākais notikuma ID: kļūda"
    Write-Host "Intervāla ID: kļūda"
    Write-Host "ticamības ziņojums: kļūda"
    Write-Host "Pasākuma 1801 skaits: 0"
    Write-Host "Pasākuma 1808 skaits: 0"
}

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

# 26. OSVersion
# PS versija: 3.0+ (Get-WmiObject 2.0 lietošanai) | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [string]:IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Nevarēja izgūt OS versiju"
        $osVersion = "Nezināms"
    } vēl {
        $osVersion = $osInfo.Version
    }
    Write-Host "Operētājsistēmas versija: $osVersion"
} tvert {
    # CIM var neizdoties dažās vidēs — izmantojiet atteici
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "Operētājsistēmas versija: $osVersion"
}

# 27. LastBootTime
# PS versija: 3.0+ (Get-WmiObject 2.0 lietošanai) | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Neizdevās izgūt pēdējās palaišanas laiku"
        $lastBootTime = $null
        Write-Host "Pēdējās sāknēšanas laiks: nav pieejams"
    } vēl {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Last Boot Time: $lastBootTime"
    }
} tvert {
    # CIM var neizdoties dažās vidēs — izmantojiet atteici
    izmēģināt {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). StartTime
    } tvert {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Last Boot Time: $lastBootTime" } else { Write-Host "Last Boot Time: Not Available" }
}

# 28. BaseBoardManufacturer
# PS versija: 3.0+ (Get-WmiObject 2.0 lietošanai) | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]:IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Could not retrieve baseboard manufacturer"
        $baseBoardManufacturer = "Nezināms"
    } vēl {
        $baseBoardManufacturer = $baseBoard.Ražotājs
    }
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
} tvert {
    # CIM var neizdoties — pamattīka informācija ir papildu
    $baseBoardManufacturer = "Nezināms"
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS versija: 3.0+ (Get-WmiObject 2.0 lietošanai) | Administrēšana: Nē | Sistēmas prasības: Nav
izmēģināt {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]:IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Nevarēja izgūt bāzes tāfeles produktu"
        $baseBoardProduct = "Nezināms"
    } vēl {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Bāzes tāfeles produkts: $baseBoardProduct"
} tvert {
    # CIM var neizdoties — pamattīka informācija ir papildu
    $baseBoardProduct = "Nezināms"
    Write-Host "Baseboard Produkts: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS versija: Visi | Administrēšana: Nē | Sistēmas prasības: pastāv ieplānots uzdevums
# Pārbauda, vai ir iespējots drošas sāknēšanas-atjaunināšanas ieplānotais uzdevums
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Nezināms"
izmēģināt {
    $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' -vai $taskData.Status -eq 'Running')
        }
    } vēl {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Iespējots: $secureBootTaskEnabled)" -PriekšplānsKrāsot dzeltena
    } vēl {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Iespējota: $secureBootTaskEnabled)" -PriekšplānaColor zaļa
    }
} tvert {
    $secureBootTaskStatus = "Kļūda"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. WinCS atslēgas statuss (F33E0C8E002 - drošas sāknēš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ēģināt {
    # Pārbaudīt bieži lietotās atrašanās vietas WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p in $possiblePaths) {
        if (Testa ceļš $p) { $wincsFlagsPath = $p; break }
    }

    if ($wincsFlagsPath) {
        # Query specific key - requires admin rights
        $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Pārbaudiet, vai tiek lietota atslēga (meklējiet "Aktīva konfigurācija" vai līdzīgu indikatoru)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Lietots"
                Write-Host "WinCS key F33E0C8E002: Applied" -ForegroundColor Green
            } elseif ($queryOutputStr -match "not found|Bez konfigurācijas") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } vēl {
                # Atslēga pastāv — pārbaudiet stāvokļa izvadi
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Applied"
                Write-Host "WinCS key F33E0C8E002: Applied" -ForegroundColor Green
            }
        } vēl {
            # Pārbaudīt, vai nav konkrētu kļūdas ziņojumu
            if ($queryOutputStr -match "Access denied|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS key F33E0C8E002: Piekļuve liegta (palaist kā administratoram)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "not found|Bez konfigurācijas") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS key F33E0C8E002: Not Applied" -ForegroundColor Yellow
            } vēl {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "WinCS Key F33E0C8E002: Query failed" -ForegroundColor Red
            }
        }
    } vēl {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS Key F33E0C8E002: WinCsFlags.exe not found" -ForegroundColor Gray
    }
} tvert {
    $wincsKeyStatus = "Kļūda"
    Write-Host "WinCS Key F33E0C8E002: Error checking - $_" -ForegroundColor Red
}              

# =============================================================================
# Remediation Detection - Status Output & Exit Code
# =============================================================================

# Build status object from all collected inventory data
$status = [pasūtījuma]@{
    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
    AparātprogrammatūraVersija = $firmwareVersion
    FirmwareReleaseDate = $firmwareReleaseDate
    OSArchitecture = $osArchitecture
    CanAttemptUpdateAfter = if ($canAttemptUpdateAfter -is [datetime]) { $canAttemptUpdateAfter.ToString("o") } else { "$canAttemptUpdateAfter" }
    LatestEventId = $latestEventId
    BucketId = $bucketId
    Confidence = $confidence
    SkipReasonZināmais_ir $skipReasonKnownIssue # KI_<> no notikuma SkipReason in BucketId
    Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Kļūdas notikumi ar tverto informāciju
    Event1795Count = $event 1795Count # Firmware returned error
    Event1795ErrorCode = $event 1795ErrorCode # Kļūdas kods no aparātprogrammatūras
    Event1796Count = $event 1796Count # Kļūdas kods
reģistrēts     Event1796ErrorCode = $event 1796ErrorCode # Tvertais kļūdas kods
    Event1800Count = $event 1800Count # Nepieciešama restartēšana (NOT kļūda)
    RebootPending = $rebootPending # True, ja ir 1800 notikumu
    Event1802Count = $event 1802Count #Known firmware issue
    KnownIssueId = $knownIssueId # KI_<number> from SkipReason
    Event1803Count = $event 1803Count # Trūkst KEK atjauninājuma
    MissingKEK = $missingKEK # OEM nepieciešams nodrošinā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 lietota atslēga
    WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound utt.
}

# Izvades statuss — datu apkopošanai
$jsonOutput = $status | ConvertTo-Json -compress

# Ja ir nodrošināts outputPath, saglabājiet failā; pretējā gadījumā izvade uz izdruku
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Validate OutputPath - skip if it looks like a help request or has invalid chars
    if ($OutputPath -match '^[/\-]' -vai $OutputPath -match '[<>:"|? *]') {
        Write-Host "Invalid OutputPath specified, outputting to stdout" -ForegroundColor Yellow
       
Write-Output $jsonOutput         if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") { exit 0 } else { exit 1 }
    }
    
    # Nodrošiniet, ka izvades mape pastāv
    if (-not (Testa-ceļš $OutputPath)) {
        izmēģināt {
            New-Item -ItemType Directory -Path $OutputPath -Force | Out-Null
        } tvert {
            Write-Warning "Nevarēja izveidot izvades mapi: $OutputPath - $_"
        }
    }
    
    # Saglabāt HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    izmēģināt {
        $jsonOutput | Out-File -FilePath $outputFile -Encoding UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } tvert {
        Write-Warning "Nevarēja rakstīt failā: $outputFile - $_"
        # Fall back to stdout
       
Write-Output $jsonOutput     }
} vēl {
    # Sākotnējā darbība — izvade uz iztrūti
   
Write-Output $jsonOutput }

# Izejas kods: "Atjaunināts" ir sekmīgas atskaņošanas grāmatas vērtība
if ($secureBootEnabled -and $uefica 2023Status -eq "Updated") {
    iziet no 0 # bez problēmas
} vēl {
    exit 1 # With issue
}