Sample Secure Boot Inventory Data Collection script

<#
. SINOPSIS
    Detectează starea de actualizare a certificatului de bootare securizat pentru monitorizare la nivelul întregii flote.

. DESCRIEREA /
    Acest script de detectare colectează secure Boot status, certificate update registry valori,
    și informațiile despre dispozitiv. Acesta creează un șir JSON pentru monitorizare și raportare.

    Compatibil cu remedierile Intune, colectarea bazată pe GPO și alte instrumente de gestionare.
Nu este necesar un script de remediere - aceasta este doar monitorizare.

    Ieșire 0 = "Fără problemă" (certificate actualizate)
    Ieșirea 1 = "Cu problema" (certificate ne actualizate - doar informativ)

. Parameter OutputPath
    Opţional. Calea către un folder în care va fi salvat fișierul JSON.
Dacă este furnizat, salvează HOSTNAME_latest.json în acest folder.
Dacă nu este furnizată, ieșire JSON la stdout (comportament original).

. EXEMPLU
    # Ieșire la ieșire (detectare Intune/SCCM)
    .\Detect-SecureBootCertUpdateStatus.ps1

. EXEMPLU
    # Salvați în partajarea de rețea (implementare GPO)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. NOTE
    Căi de registry per 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
    IMPLICITE, INCLUSIV, DAR FĂRĂ A SE LIMITA LA GARANȚIILE DE VANDABILITATE,
    ADECVAREA PENTRU UN ANUMIT SCOP ȘI NEINFRINGEMENT. ÎN NICI UN CAZ NU
SE VA     AUTORII SAU DEȚINĂTORII DE DREPTURI DE AUTOR SUNT RĂSPUNZĂTORI PENTRU ORICE REVENDICARE, DAUNE SAU ALTE
    RĂSPUNDEREA, FIE ÎNTR-O ACȚIUNE CONTRACTUALĂ, DELICTUALĂ SAU ÎN ALT MOD, CARE DECURGE DIN,
    ÎN AFARA SOFTWARE-ULUI SAU ÎN LEGĂTURĂ CU ACEASTA, CU UTILIZAREA SAU ALTE TRANZACȚII ÎN
    SOFTWARE.
#>
param(
    [Parametru(Obligatoriu = $false)]
    [șir]$OutputPath
)

# Download URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples"
# Notă: Acest script rulează pe punctele finale pentru a colecta date de stare Secure Boot.

# 1. Hostname
# PS Versiune: Toate | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $hostname = $env:COMPUTERNAME
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Numele gazdei nu a putut fi determinat"
        $hostname = "Necunoscut"
    }
    Write-Host "Nume gazdă: $hostname"
} captură {
    Write-Warning "Eroare la regăsirea numelui de gazdă: $_"
    $hostname = "Eroare"
    Write-Host "Nume gazdă: $hostname"
}

# 2. CollectionTime
# PS Versiune: Toate | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $collectionTime = Get-Date
    dacă ($null -eq $collectionTime) {
        Write-Warning "Imposibil de regăsit data/ora curentă"
        $collectionTime = "Necunoscut"
    }
    Write-Host "Timp colecție: $collectionTime"
} captură {
    Write-Warning "Eroare la regăsirea datei/orei: $_"
    $collectionTime = "Eroare"
    Write-Host "Timp colecție: $collectionTime"
}

# Registry: Secure Boot Main Key (3 valori)

# 3. SecureBootEnabled
# PS Versiune: 3.0+ | Admin: Poate fi necesar | Cerințe de sistem: sistem
capabil de bootare UEFI/Secure încercați {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Boot securizat activat: $secureBootEnabled"
} captură {
    Write-Warning "Nu se poate determina starea bootării securizate prin cmdlet: $_"
    # Try registry fallback
    încercați {
        $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Boot securizat activat: $secureBootEnabled"
    } captură {
        Write-Warning "Nu se poate determina starea Secure Boot prin registry. Sistemul poate să nu accepte UEFI/Boot secure."
        $secureBootEnabled = $null
        Write-Host "Boot securizat activat: indisponibil"
    }
}

# 4. HighConfidenceOptOut
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Renunțare cu încredere maximă: $highConfidenceOptOut"
} captură {
    # HighConfidenceOptOut este opțional - nu este prezent pe majoritatea sistemelor
    $highConfidenceOptOut = $null
    Write-Host "Renunțare de mare încredere: Ne setat"
}

Nr. 4b. MicrosoftUpdateManagedOptIn
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Înscriere gestionată Microsoft Update: $microsoftUpdateManagedOptIn"
} captură {
    # MicrosoftUpdateManagedOptIn este opțional - nu este prezent pe majoritatea sistemelor
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Înscriere gestionată Microsoft Update: Ne set"
}

# 5. AvailableUpdates
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    dacă ($null -ne $availableUpdates) {
        # Conversie în format
hexazecimal         $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host "Disponibil Actualizări: $availableUpdatesHex"
    } altfel, {
        Write-Host "Disponibil Actualizări: Indisponibil"
    }
} captură {
    Write-Warning "Cheia de registry AvailableUpdates nu a fost găsită sau inaccesibilă"
    $availableUpdates = $null
    Write-Host "Disponibil Actualizări: Indisponibil"
}

Nr. 5b. AvailableUpdatesPolicy (valoare persistentă controlată de GPO)
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    dacă ($null -ne $availableUpdatesPolicy) {
        # Conversie în format
hexazecimal         $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Politica de Actualizări disponibilă: $availableUpdatesPolicyHex"
    } altfel, {
        Write-Host "Politică de Actualizări disponibilă: Ne set"
    }
} captură {
    # AvailableUpdatesPolicy este opțional - se setează doar atunci când se aplică
GPO     $availableUpdatesPolicy = $null
    Write-Host "Politică de Actualizări disponibilă: Ne set"
}

# Registry: Cheie de servicii (3 valori)

# 6. UEFICA2023Status
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Starea Windows UEFI CA 2023: $uefica 2023Status"
} captură {
    Write-Warning "Cheia de registry de stare Windows UEFI CA 2023 nu a fost găsită sau inaccesibilă"
    $uefica 2023Status = $null
    Write-Host "Stare Windows UEFI CA 2023: Indisponibil"
}

# 7. UEFICA2023Eroare
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Eroare = $regValue.UEFICA2023Error
    Write-Host eroarea "UEFI CA 2023: $uefica 2023Error"
} captură {
    # UEFICA2023Eroare există doar dacă a existat o eroare - absența este bună
    $uefica 2023Eroare = $null
    Write-Host "Eroare UEFI CA 2023: Fără"
}

# 8. UEFICA2023ErrorEvent
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "Eveniment de eroare UEFI CA 2023: $uefica 2023ErrorEvent"
} captură {
    $uefica 2023ErrorEvent = $null
    Write-Host "Eveniment de eroare UEFI CA 2023: Indisponibil"
}

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

# 9. OEMManufacturerName
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([string]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName este gol"
        $oemManufacturerName = "Necunoscut"
    }
    Write-Host "Nume producător OEM: $oemManufacturerName"
} captură {
    Write-Warning cheia de registry "OEMManufacturerName nu a fost găsită sau inaccesibilă"
    $oemManufacturerName = $null
    Write-Host "Nume producător OEM: Indisponibil"
}

# 10. OEMModelSystemFamily
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelSystemFamily -ErrorAction Stop
    $oemModelSystemFamily = $regValue.OEMModelSystemFamily
    if ([string]::IsNullOrEmpty($oemModelSystemFamily)) {
        Write-Warning "OEMModelSystemFamily este gol"
        $oemModelSystemFamily = "Necunoscut"
    }
    Write-Host "Familie de modele OEM: $oemModelSystemFamily"
} captură {
    Write-Warning "Cheia de registry OEMModelSystemFamily nu a fost găsită sau nu este inaccesibilă"
    $oemModelSystemFamily = $null
    Write-Host "Familie de modele OEM: Indisponibil"
}

# 11. NumărModel
OEM # PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMModelNumber -ErrorAction Stop
    $oemModelNumber = $regValue.OEMModelNumber
    if ([string]::IsNullOrEmpty($oemModelNumber)) {
        Write-Warning "OEMModelNumber este gol"
        $oemModelNumber = "Necunoscut"
    }
    Write-Host "Număr model OEM: $oemModelNumber"
} captură {
    Write-Warning "Cheia de registry OEMModelNumber nu a fost găsită sau inaccesibilă"
    $oemModelNumber = $null
    Write-Host "Număr model OEM: Indisponibil"
}

# 12. FirmwareVersion
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([string]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion este gol"
        $firmwareVersion = "Necunoscut"
    }
    Write-Host "Versiune firmware: $firmwareVersion"
} captură {
    Write-Warning "Cheia de registry FirmwareVersion nu a fost găsită sau inaccesibilă"
    $firmwareVersion = $null
    Write-Host "Versiune firmware: indisponibilă"
}

# 13. FirmwareReleaseDate
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareReleaseDate -ErrorAction Stop
    $firmwareReleaseDate = $regValue.FirmwareReleaseDate
    if ([string]::IsNullOrEmpty($firmwareReleaseDate)) {
        Write-Warning "FirmwareReleaseDate este gol"
        $firmwareReleaseDate = "Necunoscut"
    }
    Write-Host "Dată lansare firmware: $firmwareReleaseDate"
} captură {
    Write-Warning "Cheia de registry FirmwareReleaseDate nu a fost găsită sau inaccesibilă"
    $firmwareReleaseDate = $null
    Write-Host "Dată lansare firmware: indisponibil"
}

# 14. OSArchitecture
# PS Versiune: Toate | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Try registry fallback
        $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OSArchitecture -ErrorAction Stop
        $osArchitecture = $regValue.OSArchitecture
    }
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        Write-Warning "OSArchitecture nu a putut fi determinată"
        $osArchitecture = "Necunoscut"
    }
    Write-Host "Arhitectură sistem de operare: $osArchitecture"
} captură {
    Write-Warning "Eroare la regăsirea OSArchitecture: $_"
    $osArchitecture = "Necunoscut"
    Write-Host "Arhitectură sistem de operare: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS Versiune: Toate | Admin: Poate fi necesar | Cerințe de sistem: Niciuna
încercați {
    $regValue = Get-ItemProperty -Cale "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Convertiți FILETIME la UTC DateTime - depozite de registry ca REG_BINARY (byte[]) sau REG_QWORD (lung)
    dacă ($null -ne $canAttemptUpdateAfter) {
        încercați {
            dacă ($canAttemptUpdateAfter -este [byte[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } captură {
            Write-Warning "Imposibil de efectuat conversia CanAttemptUpdateAfter FILETIME la DateTime"
        }
    }
    Write-Host "Se poate încerca actualizarea după: $canAttemptUpdateAfter"
} captură {
    Write-Warning "CanAttemptUpdateAfter cheia de registry nu a fost găsită sau nu este accesibilă"
    $canAttemptUpdateAfter = $null
    Write-Host "Se poate încerca actualizarea după: indisponibil"
}

# Jurnale de evenimente: Jurnal de sistem (10 valori: 16-25)

# 16-25. Interogări jurnal de evenimente
ID-uri eveniment #:
# 1801 - Actualizare inițiată, repornire necesară
# 1808 - Actualizare finalizată cu succes
# 1795 - Eroare de firmware returnată (cod de eroare de captură)
# 1796 - Eroare înregistrată cu codul de eroare (cod de captură)
# 1800 - Repornire necesară (NU este o eroare - actualizarea va continua după repornire)
# 1802 - Cunoscut problemă de firmware blocat actualizare (captura KI_<numărul> de la SkipReason)
# 1803 - Potrivire KEK actualizare nu a fost găsit (OEM trebuie să furnizeze KEK semnat PK)
# PS Versiune: 3.0+ | Admin: Poate fi necesar pentru jurnalul de sistem | Cerințe de sistem: Niciuna
încercați {
    # Interogați toate ID-urile
de eveniment Secure Boot relevante     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    dacă ($events. Count -eq 0) {
        Write-Warning "Nu s-au găsit evenimente secure boot în jurnalul de sistem"
        $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 "Cel mai recent ID eveniment: indisponibil"
        Write-Host "ID bucket: indisponibil"
        Write-Host "Încredere: indisponibil"
        Write-Host "Contor eveniment 1801: 0"
        Write-Host "Contor eveniment 1808: 0"
    } altfel, {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated -Descendent | Select-Object -Primul 1
        dacă ($null -eq $latestEvent) {
            Write-Warning "Nu s-a putut determina cel mai recent eveniment"
            $latestEventId = $null
            Write-Host "Cel mai recent ID eveniment: Indisponibil"
        } altfel, {
            $latestEventId = latestEvent.Id
de lei             Write-Host "Cel mai recent ID eveniment: $latestEventId"
        }

        # 17. BucketID - extras din evenimentul 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trim()
                Write-Host "ID bucket: $bucketId"
            } altfel, {
                Write-Warning "BucketId negăsit în mesajul evenimentului"
                $bucketId = $null
                Write-Host "ID bucket: Negăsit în eveniment"
            }
        } altfel, {
            Write-Warning "Cel mai recent eveniment sau mesaj este nul, nu se poate extrage BucketId"
            $bucketId = $null
            Write-Host "ID bucket: Indisponibil"
        }

        # 18. Încredere - extras din evenimentul 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trim()
                Write-Host "Încredere: $confidence"
            } altfel, {
                Write-Warning "Nivelul de încredere nu s-a găsit în mesajul eveniment"
                $confidence = $null
                Write-Host "Încredere: Negăsit în eveniment"
            }
        } altfel, {
            Write-Warning "Cel mai recent eveniment sau mesaj este nul, nu poate extrage Confidence"
            $confidence = $null
            Write-Host "Încredere: indisponibil"
        }

        Nr. 18b. SkipReason - extragerea numărului KI_<> din SkipReason în același eveniment ca BucketId
        # Aceasta capturează ID-urile de probleme cunoscute care apar alături de BucketId/Confidence (nu doar evenimentul 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 "Problemă cunoscută SkipReason: $skipReasonKnownIssue" - Culoare prim plan galben
            }
        }

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

        # 20. Eveniment1808Count
        $event 1808Array = @($events | Where-Object {$_. Id -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Contor eveniment 1808: $event 1808Count"
        
        # Inițializați variabilele evenimentului de
eroare         $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
        
        # Verificați evenimentele de eroare doar dacă actualizarea NU este finalizată
        # Skip error analysis if: 1808 is latest event OR UEFICA2023Status is "Updated"
        $updateComplete = ($latestEventId -eq 1808) -sau ($uefica 2023Status -eq "Actualizat")
        
        dacă (-nu $updateComplete) {
            Write-Host "Actualizarea nu s-a terminat - se verifică evenimentele de eroare..." -Culoare prim plan galben
            
            # 21. Eveniment1795 - Eroare de firmware (cod de eroare de captură)
            $event 1795Array = @($events | Where-Object {$_. Id -eq 1795})
            $event 1795Count = $event 1795Array.Count
            dacă ($event 1795Count -gt 0) {
                $latestEvent 1795 = $event 1795Array | Sort-Object TimeCreated -Descending | Select-Object -Primul 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 contor "Eveniment 1795 (Eroare firmware): $event 1795Count" $(if ($event 1795ErrorCode) { "Cod: $event 1795ErrorCode" })
            }
            
            # 22. Eveniment1796 - cod de eroare înregistrat (cod de eroare de captură)
            $event 1796Array = @($events | Where-Object {$_. Id -eq 1796})
            $event 1796Count = $event 1796Array.Count
            dacă ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object TimeCreated -Descending | Select-Object -Primul 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 contor "Eveniment 1796 (eroare înregistrată): $event 1796Count" $(if ($event 1796ErrorCode) { "Cod: $event 1796ErrorCode" })
            }
            
            # 23. Event1800 - Repornire necesară (NU este necesară o eroare - actualizarea va continua după repornire)
            $event 1800Array = @($events | Where-Object {$_. Id -eq 1800})
            $event 1800Count = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            dacă ($rebootPending) {
                Write-Host "Evenimentul 1800 (repornire în așteptare): actualizarea va continua după repornire" -Prim-planColor Cyan
            }
            
            # 24. Event1802 - problemă de firmware cunoscută (capturarea numărului KI_<> din SkipReason)
            $event 1802Array = @($events | Where-Object {$_. Id -eq 1802})
            $event 1802Count = $event 1802Array.Count
            dacă ($event 1802Count -gt 0) {
                $latestEvent 1802 = $event 1802Array | Sort-Object TimeCreated -Descending | Select-Object -Primul 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host contorul "Eveniment 1802 (problemă de firmware cunoscută): $event 1802Count" $(dacă ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 - Actualizare KEK lipsă (OEM trebuie să furnizeze KEK semnat PK)
            $event 1803Array = @($events | Where-Object {$_. Id -eq 1803})
            $event 1803Count = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            dacă ($missingKEK) {
                Write-Host "Evenimentul 1803 (KEK lipsă): OEM trebuie să furnizeze KEK semnat PK" -Prim-planColor galben
            }
        } altfel, {
            Write-Host "Actualizare terminată (evenimentul 1808 sau Starea=actualizată) - se ignoră analiza erorilor" -Prim-planColor Verde
        }
    }
} captură {
    Write-Warning "Eroare la regăsirea jurnalelor de evenimente. Pot fi necesare privilegii de administrator: $_"
    $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 "CEL mai recent ID eveniment: eroare"
    Write-Host "ID bucket: eroare"
    Write-Host "Încredere: eroare"
    Write-Host "Contor eveniment 1801: 0"
    Write-Host "Contor eveniment 1808: 0"
}

# Interogări WMI/CIM (5 valori)

# 26. Versiune OSVersion
# PS Versiune: 3.0+ (utilizarea Get-WmiObject pentru 2.0) | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Imposibil de regăsit versiunea sistemului de operare"
        $osVersion = "Necunoscut"
    } altfel, {
        $osVersion = $osInfo.Version
    }
    Write-Host "Versiune sistem de operare: $osVersion"
} captură {
    # CIM poate să nu reușească în unele medii - utilizarea rezervă
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "Versiune sistem de operare: $osVersion"
}

# 27. Ora ultimei încărcări
# PS Versiune: 3.0+ (utilizarea Get-WmiObject pentru 2.0) | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    dacă ($null -eq $osInfo -sau $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Imposibil de regăsit ora ultimei încărcări"
        $lastBootTime = $null
        Write-Host "Ora ultimei încărcări: indisponibilă"
    } altfel, {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Ora ultimei încărcări: $lastBootTime"
    }
} captură {
    # CIM poate să nu reușească în unele medii - utilizarea rezervă
    încercați {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Oră de
început     } captură {
        $lastBootTime = $null
    }
    dacă ($lastBootTime) { Write-Host "Ora ultimei încărcări: $lastBootTime" } altcineva { Write-Host "Ora ultimei încărcări: Indisponibil" }
}

# 28. BaseBoardManufacturer
# PS Versiune: 3.0+ (utilizarea Get-WmiObject pentru 2.0) | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Imposibil de regăsit producătorul plăcii de bază"
        $baseBoardManufacturer = "Necunoscut"
    } altfel, {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Producător tablă de bază: $baseBoardManufacturer"
} captură {
    # CIM poate eșua - baseboard info este suplimentar
    $baseBoardManufacturer = "Necunoscut"
    Write-Host "Producător placă de bază: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS Versiune: 3.0+ (utilizarea Get-WmiObject pentru 2.0) | Admin: Nu | Cerințe de sistem: Niciuna
încercați {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Imposibil de regăsit produsul din tabla de bază"
        $baseBoardProduct = "Necunoscut"
    } altfel, {
        $baseBoardProduct = $baseBoard.Produs
    }
    Write-Host "Produs tablă de bază: $baseBoardProduct"
} captură {
    # CIM poate eșua - baseboard info este suplimentar
    $baseBoardProduct = "Necunoscut"
    Write-Host "Produs tablă de bază: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS Versiune: Toate | Admin: Nu | Cerințe de sistem: Activitatea planificată există
# Verifică dacă activitatea programată Secure-Boot-Update este activată
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Necunoscut"
încercați {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    dacă ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | ConvertFrom-Csv
        dacă ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Ready' -sau $taskData.Status -eq 'Running')
        }
    } altfel, {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    dacă ($secureBootTaskEnabled -eq $false) {
        Write-Host "Actualizare SecureBoot Activitate: $secureBootTaskStatus (Activat: $secureBootTaskEnabled)" -Culoare prim plan galben
    } altfel, {
        Write-Host "Actualizare SecureBoot Activitate: $secureBootTaskStatus (activat: $secureBootTaskEnabled)" -Culoare prim plan verde
    }
} captură {
    $secureBootTaskStatus = "Eroare"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Error checking - $_" -ForegroundColor Red
}

# 31. Stare cheie WinCS (F33E0C8E002 - Actualizare certificat de bootare securizată)
# PS Versiune: Toate | Admin: Da (pentru interogare) | Cerințe de sistem: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Necunoscut"
încercați {
    # Verificați locațiile comune pentru WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p în $possiblePaths) {
        if (Test-Path $p) { $wincsFlagsPath = $p; break }
    }

    dacă ($wincsFlagsPath) {
        # Cheie specifică interogării - necesită drepturi
de administrator         $queryOutput = & $wincsFlagsPath /query - F33E0C8E002 cheie 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        dacă ($LASTEXITCODE -eq 0) {
            # Verificați dacă este aplicată tasta (căutați "Configurare activă" sau un indicator similar)
            dacă ($queryOutputStr -se potrivesc cu "Configurare activă.*:.*activat" -sau $queryOutputStr -se potrivesc cu "Configurare.*aplicat") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Aplicat"
                Write-Host "F33E0C8E002 cheie WinCS: Applied" -Prim planColor - Verde
            } elseif ($queryOutputStr -potrivire "negăsit|Nicio configurație") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "Neaplicat"
                Write-Host "F33E0C8E002 cheie WinCS: Neaplicat" -Culoare prim plan galben
            } altfel, {
                # Cheia există - verificați ieșirea pentru stare
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Aplicat"
                Write-Host "F33E0C8E002 cheie WinCS: Applied" -Prim planColor - Verde
            }
        } altfel, {
            # Verificați dacă există mesaje
de eroare specifice             dacă ($queryOutputStr se potrivesc cu "Acces refuzat|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "F33E0C8E002 cheie WinCS: Acces refuzat (rulați ca administrator)" -Prim-planColor DarkGray
            } elseif ($queryOutputStr -potrivire "negăsit|Nicio configurație") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "Neaplicat"
                Write-Host "F33E0C8E002 cheie WinCS: Neaplicat" -Culoare prim plan galben
            } altfel, {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "F33E0C8E002 cheie WinCS: Interogare nereușită" -Culoare prim plan roșu
            }
        }
    } altfel, {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "F33E0C8E002 cheie WinCS: WinCsFlags.exe negăsit" -Culoare prim plan gri
    }
} captură {
    $wincsKeyStatus = "Eroare"
    Write-Host "F33E0C8E002 cheie WinCS: Verificare erori - $_" -Prim-planColor roșu
}              

Nr. =============================================================================
# Detectare remediere - ieșire stare & Cod
de ieșire # =============================================================================

# Build status object from all collected inventory data
$status = [ordonat]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Eroare = $uefica 2023Eroare
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = dacă ($null -ne $availableUpdates) { $availableUpdatesHex } altcineva { $null }
    AvailableUpdatesPolicy = dacă ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } altcineva { $null }
    Hostname = $hostname
    CollectionTime = dacă ($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 = dacă ($canAttemptUpdateAfter -is [datetime]) { $canAttemptUpdateAfter.ToString("o") } else { "$canAttemptUpdateAfter" }
    LatestEventId = $latestEventId
    BucketId = $bucketId
    Încredere = $confidence
    SkipReasonKnownIssue = numărul $skipReasonKnownIssue # KI_<> din SkipReason în evenimentul
BucketId     Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Evenimente de eroare cu detalii
capturate     Eveniment1795Count = $event 1795Count # Eroare
de firmware returnată     Event1795ErrorCode = $event 1795ErrorCode # Codul de eroare din firmware
    Event1796Count = $event 1796Count # Codul de eroare înregistrat
    Event1796ErrorCode = $event 1796ErrorCode # Codul
de eroare capturat     Event1800Count = $event 1800Count # Repornire necesară (NU este o eroare)
    RebootPending = $rebootPending # True dacă evenimentul 1800 este prezent
    Event1802Count = $event 1802Count # Problemă
de firmware cunoscută     KnownIssueId = $knownIssueId # KI_<> numărului din SkipReason
    Event1803Count = $event 1803Count # Actualizare KEK
lipsă     MissingKEK = $missingKEK # OEM trebuie să furnizeze KEK
semnat PK     OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True dacă se aplică
F33E0C8E002 cheie     WinCSKeyStatus = $wincsKeyStatus # Aplicat, NotApplied, WinCsFlagsNotFound etc.
}

# Ieșire stare - Pentru agregarea
datelor $jsonOutput = $status | ConvertTo-Json - Comprimare

# Dacă s-a furnizat OutputPath, salvați în fișier; în caz contrar, ieșire la ieșire
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Validați OutputPath - omiteți dacă arată ca o solicitare de ajutor sau dacă are caractere nevalide
    dacă ($OutputPath -match '^[/\-]' -sau $OutputPath -match '[<>:"|? *]') {
        Write-Host "Cale de ieșire nevalidă specificată, ieșire la stdout" -Culoare prim plan galben
       
Write-Output $jsonOutput         dacă ($secureBootEnabled -and $uefica 2023Status -eq "Actualizat") { exit 0 } else { exit 1 }
    }
    
    # Asigurați-vă că folderul de ieșire există
    if (-not (Test-Path $OutputPath)) {
        încercați {
            New-Item -ItemType Directory -Path $OutputPath -Force | Nul în
exterior         } captură {
            Write-Warning "Imposibil de creat folderul de ieșire: $OutputPath - $_"
        }
    }
    
    # Salvare în HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    încercați {
        $jsonOutput | Out-File -FilePath $outputFile -codificare UTF8 -Force
        Write-Host "JSON salvat în: $outputFile" -Prim planColor Verde
    } captură {
        Write-Warning "Imposibil de scris în fișierul: $outputFile - $_"
        # Fall back to stdout
       
Write-Output $jsonOutput     }
} altfel, {
    # Comportamentul original - ieșire la stdout
   
Write-Output $jsonOutput }

# Cod de ieșire: "Actualizat" este valoarea de succes pe playbook
dacă ($secureBootEnabled -și $uefica 2023Status -eq "Actualizat") {
    exit 0 # Fără problemă
} altfel, {
    exit 1 # Cu problema
}