Exempel på skript för insamling av lagerdata för säker start

<#
. SYNOPSIS
    Identifierar status för uppdatering av certifikat för säker start för övervakning över hela flottan.

. BESKRIVNING
    Det här identifieringsskriptet samlar in status för säker start, registervärden för certifikatuppdatering,
    och enhetsinformation. En JSON-sträng matas ut för övervakning och rapportering.

    Kompatibel med Intune åtgärder, GPO-baserad samling och andra hanteringsverktyg.
Inget åtgärdsskript behövs – det här är endast övervakning.

    Exit 0 = "Without issue" (certifikat har uppdaterats)
    Exit 1 = "With issue" (certifikat uppdateras inte – endast information)

. PARAMETER OutputPath
    Valfri. Sökväg till en mapp där JSON-filen sparas.
Om det anges sparar HOSTNAME_latest.json i den här mappen.
Om det inte anges matas JSON ut till stdout (ursprungligt beteende).

. EXEMPEL
    # Utdata till stdout (identifiering av Intune/SCCM)
    .\Detect-SecureBootCertUpdateStatus.ps1

. EXEMPEL
    # Spara på nätverksresurs (GPO-distribution)
    .\Detect-SecureBootCertUpdateStatus.ps1 -OutputPath "\\server\SecureBootLogs$"

. ANTECKNINGAR
    Registersökvägar per https://aka.ms/securebootplaybook:
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot
      HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing

    PROGRAMVARAN TILLHANDAHÅLLS "I BEFINTLIGT FALL", UTAN NÅGRA SOM HELST GARANTIER,
    UNDERFÖRSTÅDDA, INKLUSIVE MEN INTE BEGRÄNSAT TILL GARANTIER VAD GÄLLER SÄLJBARHET,
    LÄMPLIGHET FÖR ETT VISST ÄNDAMÅL OCH ICKE-INFRINGEMENT. UNDER INGA OMSTÄNDIGHETER FÅR
    FÖRFATTARE ELLER COPYRIGHT-INNEHAVARE ANSVARAR FÖR ALLA ANSPRÅK, SKADOR ELLER ANDRA
    ANSVAR, OAVSETT KONTRAKTSÅTGÄRD, SKADESTÅNDSANSVAR ELLER ANNAT SOM UPPKOMMER FRÅN,
    AV ELLER I ANSLUTNING TILL PROGRAMVARAN ELLER ANVÄNDNING ELLER ANNAN HANTERING AV
    PROGRAMVARA.
#>
param(
    [Parameter(Obligatoriskt = $false)]
    [sträng]$OutputPath
)

# Ladda ner URL: https://aka.ms/getsecureboot -> "Deployment and Monitoring Samples"
# Obs! Det här skriptet körs på slutpunkter för att samla in statusdata för säker start.

# 1. Värdnamn
# PS-version: Alla | Admin: Nej | Systemkrav: Inga
prova {
    $hostname = $env:COMPUTERNAME
    if ([string]::IsNullOrEmpty($hostname)) {
        Write-Warning "Det gick inte att fastställa värdnamnet"
        $hostname = "Okänd"
    }
    Write-Host "Hostname: $hostname"
} fångst {
    Write-Warning "Fel vid hämtning av värdnamn: $_"
    $hostname = "Fel"
    Write-Host "Hostname: $hostname"
}

# 2. CollectionTime
# PS-version: Alla | Admin: Nej | Systemkrav: Inga
prova {
    $collectionTime = Get-Date
    if ($null -eq $collectionTime) {
        Write-Warning "Det gick inte att hämta dagens datum/tid"
        $collectionTime = "Okänd"
    }
    Write-Host "Insamlingstid: $collectionTime"
} fångst {
    Write-Warning "Fel vid hämtning av datum/tid: $_"
    $collectionTime = "Fel"
    Write-Host "Insamlingstid: $collectionTime"
}

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

# 3. SecureBootEnabled
# PS-version: 3.0+ | Admin: Kan krävas | Systemkrav: UEFI/Secure Boot capable system
prova {
    $secureBootEnabled = Confirm-SecureBootUEFI -ErrorAction Stop
    Write-Host "Säker start aktiverad: $secureBootEnabled"
} fångst {
    Write-Warning "Det går inte att fastställa status för säker start via cmdlet: $_"
    # Prova registeråterkoppling
    prova {
        $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\State" -Name UEFISecureBootEnabled -ErrorAction Stop
        $secureBootEnabled = [bool]$regValue.UEFISecureBootEnabled
        Write-Host "Säker start aktiverad: $secureBootEnabled"
    } fångst {
        Write-Warning "Det går inte att fastställa status för säker start via registret. Systemet kanske inte stöder UEFI/Säker start."
        $secureBootEnabled = $null
        Write-Host "Säker start aktiverad: Inte tillgänglig"
    }
}

# 4. HighConfidenceOptOut
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name HighConfidenceOptOut -ErrorAction Stop
    $highConfidenceOptOut = $regValue.HighConfidenceOptOut
    Write-Host "Avregistrera dig från högt förtroende: $highConfidenceOptOut"
} fångst {
    # HighConfidenceOptOut är valfritt – finns inte på de flesta system
    $highConfidenceOptOut = $null
    Write-Host "High Confidence Opt Out: Not Set"
}

# 4b. MicrosoftUpdateManagedOptIn
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name MicrosoftUpdateManagedOptIn -ErrorAction Stop
    $microsoftUpdateManagedOptIn = $regValue.MicrosoftUpdateManagedOptIn
    Write-Host "Microsoft Update Managed Opt In: $microsoftUpdateManagedOptIn"
} fångst {
    # MicrosoftUpdateManagedOptIn är valfritt – finns inte på de flesta system
    $microsoftUpdateManagedOptIn = $null
    Write-Host "Microsoft Update Managed Opt In: Not Set"
}

# 5. AvailableUpdates
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdates -ErrorAction Stop
    $availableUpdates = $regValue.AvailableUpdates
    if ($null -ne $availableUpdates) {
        # Konvertera till hexadecimalt format
        $availableUpdatesHex = "0x{0:X}" -f $availableUpdates
        Write-Host Tillgänglig Uppdateringar: $availableUpdatesHex
    } annars {
        Write-Host "Tillgänglig Uppdateringar: Inte tillgänglig"
    }
} fångst {
    Write-Warning "AvailableUpdates registry key not found or inaccessible"
    $availableUpdates = $null
    Write-Host "Tillgänglig Uppdateringar: Inte tillgänglig"
}

# 5b. AvailableUpdatesPolicy (GPO-kontrollerat beständiga värde)
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot" -Name AvailableUpdatesPolicy -ErrorAction Stop
    $availableUpdatesPolicy = $regValue.AvailableUpdatesPolicy
    if ($null -ne $availableUpdatesPolicy) {
        # Konvertera till hexadecimalt format
        $availableUpdatesPolicyHex = "0x{0:X}" -f $availableUpdatesPolicy
        Write-Host "Tillgänglig Uppdateringar-princip: $availableUpdatesPolicyHex"
    } annars {
        Write-Host "Tillgänglig Uppdateringar-princip: Ej angivet"
    }
} fångst {
    # AvailableUpdatesPolicy är valfritt – anges bara när GPO används
    $availableUpdatesPolicy = $null
    Write-Host "Tillgänglig Uppdateringar-princip: Ej angivet"
}

# Registry: Servicing Key (3 värden)

# 6. UEFICA2023Status
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Status -ErrorAction Stop
    $uefica 2023Status = $regValue.UEFICA2023Status
    Write-Host "Windows UEFI CA 2023 Status: $uefica 2023Status"
} fångst {
    Write-Warning "Windows UEFI CA 2023 Status registernyckel hittades inte eller är inte tillgänglig"
    $uefica 2023Status = $null
    Write-Host "Windows UEFI CA 2023 Status: Inte tillgänglig"
}

# 7. UEFICA2023Fel
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023Error -ErrorAction Stop
    $uefica 2023Fel = $regValue.UEFICA2023Fel
    Write-Host "UEFI CA 2023 Fel: $uefica 2023Fel"
} fångst {
    # UEFICA2023Fel finns bara om ett fel uppstod – frånvaro är bra
    $uefica 2023Fel = $null
    Write-Host "UEFI CA 2023 Error: None"
}

# 8. UEFICA2023ErrorEvent
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing" -Name UEFICA2023ErrorEvent -ErrorAction Stop
    $uefica 2023ErrorEvent = $regValue.UEFICA2023ErrorEvent
    Write-Host "UEFI CA 2023 Felhändelse: $uefica 2023ErrorEvent"
} fångst {
    $uefica 2023ErrorEvent = $null
    Write-Host "UEFI CA 2023 Error Event: Not Available"
}

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

# 9. OEMManufacturerName
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name OEMManufacturerName -ErrorAction Stop
    $oemManufacturerName = $regValue.OEMManufacturerName
    if ([string]::IsNullOrEmpty($oemManufacturerName)) {
        Write-Warning "OEMManufacturerName is empty"
        $oemManufacturerName = "Okänd"
    }
    Write-Host "OEM-tillverkarens namn: $oemManufacturerName"
} fångst {
    Write-Warning "OEMManufacturerName-registernyckeln hittades inte eller var inte tillgänglig"
    $oemManufacturerName = $null
    Write-Host "OEM-tillverkarens namn: Inte tillgängligt"
}

# 10. OEMModelSystemFamily
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $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 är tomt"
        $oemModelSystemFamily = "Okänd"
    }
    Write-Host "OEM Model System Family: $oemModelSystemFamily"
} fångst {
    Write-Warning registernyckeln OEMModelSystemFamily hittades inte eller var inte tillgänglig
    $oemModelSystemFamily = $null
    Write-Host "OEM Model System Family: Not Available"
}

# 11. OEMModelNumber
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $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 är tomt"
        $oemModelNumber = "Okänd"
    }
    Write-Host "OEM-modellnummer: $oemModelNumber"
} fångst {
    Write-Warning "OEMModelNumber-registernyckeln hittades inte eller var inte tillgänglig"
    $oemModelNumber = $null
    Write-Host "OEM-modellnummer: Inte tillgängligt"
}

# 12. FirmwareVersion
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name FirmwareVersion -ErrorAction Stop
    $firmwareVersion = $regValue.FirmwareVersion
    if ([string]::IsNullOrEmpty($firmwareVersion)) {
        Write-Warning "FirmwareVersion är tom"
        $firmwareVersion = "Okänd"
    }
    Write-Host "Version av inbyggd programvara: $firmwareVersion"
} fångst {
    Write-Warning "Registernyckeln FirmwareVersion hittades inte eller är inte tillgänglig"
    $firmwareVersion = $null
    Write-Host "Version av inbyggd programvara: Inte tillgänglig"
}

# 13. FirmwareReleaseDate
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $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"
        $firmwareReleaseDate = "Okänd"
    }
    Write-Host "Utgivningsdatum för inbyggd programvara: $firmwareReleaseDate"
} fångst {
    Write-Warning "Registernyckeln FirmwareReleaseDate hittades inte eller var inte tillgänglig"
    $firmwareReleaseDate = $null
    Write-Host "Utgivningsdatum för inbyggd programvara: Inte tillgängligt"
}

# 14. OSArchitecture
# PS-version: Alla | Admin: Nej | Systemkrav: Inga
prova {
    $osArchitecture = $env:PROCESSOR_ARCHITECTURE
    if ([string]::IsNullOrEmpty($osArchitecture)) {
        # Prova registeråterkoppling
        $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 kunde inte fastställas"
        $osArchitecture = "Okänd"
    }
    Write-Host "OS-arkitektur: $osArchitecture"
} fångst {
    Write-Warning "Fel vid hämtning av OSArchitecture: $_"
    $osArchitecture = "Okänd"
    Write-Host "OS-arkitektur: $osArchitecture"
}

# 15. CanAttemptUpdateAfter (FILETIME)
# PS-version: Alla | Admin: Kan krävas | Systemkrav: Inga
prova {
    $regValue = Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\Servicing\DeviceAttributes" -Name CanAttemptUpdateAfter -ErrorAction Stop
    $canAttemptUpdateAfter = $regValue.CanAttemptUpdateAfter
    # Konvertera FILETIME till UTC DateTime – registerarkiv som REG_BINARY (byte[]) eller REG_QWORD (lång)
    if ($null -ne $canAttemptUpdateAfter) {
        prova {
            if ($canAttemptUpdateAfter -is [byte[]]) {
                $fileTime = [BitConverter]::ToInt64($canAttemptUpdateAfter, 0)
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($fileTime). ToUniversalTime()
            } elseif ($canAttemptUpdateAfter -is [long]) {
                $canAttemptUpdateAfter = [DateTime]::FromFileTime($canAttemptUpdateAfter). ToUniversalTime()
            }
        } fångst {
            Write-Warning "Det gick inte att konvertera CanAttemptUpdateAfter FILETIME till DateTime"
        }
    }
    Write-Host "Kan försöka uppdatera efter: $canAttemptUpdateAfter"
} fångst {
    Write-Warning "CanAttemptUpdateAfter registernyckel hittades inte eller är inte tillgänglig"
    $canAttemptUpdateAfter = $null
    Write-Host "Kan försöka uppdatera efter: Inte tillgängligt"
}

# Händelseloggar: Systemlogg (10 värden: 16-25)

# 16-25. Frågor i händelseloggen
# Händelse-ID:
# 1801 – Uppdatering initierad, omstart krävs
# 1808 – uppdateringen har slutförts
# 1795 – Fel returnerad inbyggd programvara (felkod för inspelning)
# 1796 – Fel som loggats med felkod (inspelningskod)
# 1800 - Omstart krävs (INTE ett fel - uppdateringen fortsätter efter omstart)
# 1802 – Känt problem med inbyggd programvara blockerad uppdatering (inspelning KI_<nummer> från SkipReason)
# 1803 – Matchande KEK-uppdatering hittades inte (OEM-tillverkaren måste leverera PK-signerad KEK)
# PS-version: 3.0+ | Admin: Kan krävas för systemlogg | Systemkrav: Inga
prova {
    # Fråga alla relevanta händelse-ID för
Säker start     $allEventIds = @(1795, 1796, 1800, 1801, 1802, 1803, 1808)
    $events = @(Get-WinEvent -FilterHashtable @{LogName='System'; ID=$allEventIds} -MaxEvents 50 -ErrorAction Stop)

    om ($events. Antal -eq 0) {
        Write-Warning "Inga säker start-händelser hittades i systemloggen"
        $latestEventId = $null
        $bucketId = $null
        $confidence = $null
        $skipReasonKnownIssue = $null
        $event 1801Antal = 0
        $event 1808Antal = 0
        $event 1795Antal = 0
        $event 1795ErrorCode = $null
        $event 1796Antal = 0
        $event 1796ErrorCode = $null
        $event 1800Antal = 0
        $rebootPending = $false
        $event 1802Antal = 0
        $knownIssueId = $null
        $event 1803Antal = 0
        $missingKEK = $false
        Write-Host "Senaste händelse-ID: Inte tillgängligt"
        Write-Host "Bucket ID: Not Available"
        Write-Host "Förtroende: Inte tillgängligt"
        Write-Host "Event 1801 Count: 0"
        Write-Host "Event 1808 Count: 0"
    } annars {
        # 16. LatestEventId
        $latestEvent = $events | Sort-Object TimeCreated -Descending | Select-Object -Första 1
        if ($null -eq $latestEvent) {
            Write-Warning "Det gick inte att fastställa den senaste händelsen"
            $latestEventId = $null
            Write-Host "Senaste händelse-ID: Inte tillgängligt"
        } annars {
            $latestEventId = $latestEvent.Id
            Write-Host "Senaste händelse-ID: $latestEventId"
        }

        # 17. BucketID – extraheras från händelse 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketId:\s*(.+)') {
                $bucketId = $matches[1]. Trimma()
                Write-Host "Bucket ID: $bucketId"
            } annars {
                Write-Warning "BucketId hittades inte i händelsemeddelande"
                $bucketId = $null
                Write-Host "Bucket ID: Hittades inte i händelse"
            }
        } annars {
            Write-Warning "Senaste händelsen eller meddelandet är null, kan inte extrahera BucketId"
            $bucketId = $null
            Write-Host "Bucket ID: Not Available"
        }

        # 18. Konfidens – extraheras från händelse 1801/1808
        if ($null -ne $latestEvent -and $null -ne $latestEvent.Message) {
            if ($latestEvent.Message -match 'BucketConfidenceLevel:\s*(.+)') {
                $confidence = $matches[1]. Trimma()
                Write-Host "Förtroende: $confidence"
            } annars {
                Write-Warning "Konfidensnivå hittades inte i händelsemeddelande"
                $confidence = $null
                Write-Host "Förtroende: Hittades inte i händelse"
            }
        } annars {
            Write-Warning "Senaste händelsen eller meddelandet är null, kan inte extrahera konfidens"
            $confidence = $null
            Write-Host "Förtroende: Inte tillgängligt"
        }

        # 18b. SkipReason – Extrahera KI_<nummer> från SkipReason i samma händelse som BucketId
        # Detta registrerar kända problem-ID:ar som visas tillsammans med BucketId/Confidence (inte bara Händelse 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– känt problem: $skipReasonKnownIssue" –FörgrundFärg gul
            }
        }

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

        # 20. Event1808Count
        $event 1808Array = @($events | Where-Object {$_. Id -eq 1808})
        $event 1808Count = $event 1808Array.Count
        Write-Host "Event 1808 Count: $event 1808Count"
        
        # Initiera felhändelsevariabler
        $event 1795Antal = 0
        $event 1795ErrorCode = $null
        $event 1796Antal = 0
        $event 1796ErrorCode = $null
        $event 1800Antal = 0
        $rebootPending = $false
        $event 1802Antal = 0
        $knownIssueId = $null
        $event 1803Antal = 0
        $missingKEK = $false
        
        # Sök bara efter felhändelser om uppdateringen INTE är klar
        # Hoppa över felanalys om: 1808 är den senaste händelsen ELLER UEFICA2023Status är "Uppdaterad"
        $updateComplete = ($latestEventId -eq 1808) -eller ($uefica 2023Status -eq "Uppdaterad")
        
        om (-inte $updateComplete) {
            Write-Host "Uppdateringen är inte slutförd – söker efter felhändelser..." -FörgrundFärg gul
            
            # 21. Händelse1795 – Fel i inbyggd programvara (felkod för inspelning)
            $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 -Första 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 (Firmware Error) Count: $event 1795Count" $(if ($event 1795ErrorCode) { "Kod: $event 1795ErrorCode" })
            }
            
            # 22. Händelse1796 – Felkod loggad (samla in felkod)
            $event 1796Array = @($events | Where-Object {$_. ID -eq 1796})
            $event 1796Antal = $event 1796Array.Count
            if ($event 1796Count -gt 0) {
                $latestEvent 1796 = $event 1796Array | Sort-Object TimeCreated -Descending | Select-Object -Första 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 "Händelse 1796 (felloggad) Antal: $event 1796Antal" $(om ($event 1796Felkod) { "Kod: $event 1796ErrorCode" })
            }
            
            # 23. Händelse1800 – Omstart krävs (INTE ett fel – uppdateringen fortsätter efter omstart)
            $event 1800Array = @($events | Where-Object {$_. Id -eq 1800})
            $event 1800Antal = $event 1800Array.Count
            $rebootPending = $event 1800Count -gt 0
            om ($rebootPending) {
                Write-Host "Händelse 1800 (väntande omstart): Uppdateringen fortsätter efter omstart" -ForegroundColor Cyan
            }
            
            # 24. Händelse1802 – Känt problem med inbyggd programvara (registrera KI_<nummer> från 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 -Första 1
                if ($latestEvent 1802.Message -match 'SkipReason:\s*(KI_\d+)') {
                    $knownIssueId = $matches[1]
                }
                Write-Host "Händelse 1802 (känt problem med inbyggd programvara) Antal: $event 1802Antal" $(om ($knownIssueId) { "KI: $knownIssueId" })
            }
            
            # 25. Event1803 – KEK Update saknas (OEM-tillverkaren måste leverera PK-signerad KEK)
            $event 1803Array = @($events | Where-Object {$_. Id -eq 1803})
            $event 1803Antal = $event 1803Array.Count
            $missingKEK = $event 1803Count -gt 0
            if ($missingKEK) {
                Write-Host "Event 1803 (missing KEK): OEM needs to supply PK signed KEK" -ForegroundColor Yellow
            }
        } annars {
            Write-Host "Uppdatering slutförd (händelse 1808 eller status=uppdaterad) – hoppar över felanalys" -FörgrundFärg grön
        }
    }
} fångst {
    Write-Warning "Fel vid hämtning av händelseloggar. Kan kräva administratörsbehörighet: $_"
    $latestEventId = $null
    $bucketId = $null
    $confidence = $null
    $skipReasonKnownIssue = $null
    $event 1801Antal = 0
    $event 1808Antal = 0
    $event 1795Antal = 0
    $event 1795ErrorCode = $null
    $event 1796Antal = 0
    $event 1796ErrorCode = $null
    $event 1800Antal = 0
    $rebootPending = $false
    $event 1802Antal = 0
    $knownIssueId = $null
    $event 1803Antal = 0
    $missingKEK = $false
    Write-Host "Senaste händelse-ID: Fel"
    Write-Host "Bucket ID: Error"
    Write-Host "Förtroende: Fel"
    Write-Host "Event 1801 Count: 0"
    Write-Host "Event 1808 Count: 0"
}

# WMI/CIM-frågor (5 värden)

# 26. OSVersion
# PS-version: 3.0+ (använd Get-WmiObject för 2.0) | Admin: Nej | Systemkrav: Inga
prova {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or [string]::IsNullOrEmpty($osInfo.Version)) {
        Write-Warning "Det gick inte att hämta OS-versionen"
        $osVersion = "Okänd"
    } annars {
        $osVersion = $osInfo.Version
    }
    Write-Host "OS-version: $osVersion"
} fångst {
    # CIM kan misslyckas i vissa miljöer – använd reservalternativ
    $osVersion = [System.Environment]::OSVersion.Version.ToString()
    if ([string]::IsNullOrEmpty($osVersion)) { $osVersion = "Unknown" }
    Write-Host "OS-version: $osVersion"
}

# 27. LastBootTime
# PS-version: 3.0+ (använd Get-WmiObject för 2.0) | Admin: Nej | Systemkrav: Inga
prova {
    $osInfo = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    if ($null -eq $osInfo -or $null -eq $osInfo.LastBootUpTime) {
        Write-Warning "Det gick inte att hämta senaste starttiden"
        $lastBootTime = $null
        Write-Host "Senaste starttid: Inte tillgänglig"
    } annars {
        $lastBootTime = $osInfo.LastBootUpTime
        Write-Host "Senaste starttid: $lastBootTime"
    }
} fångst {
    # CIM kan misslyckas i vissa miljöer – använd reservalternativ
    prova {
        $lastBootTime = (Get-Process -Id 0 -ErrorAction SilentlyContinue). Starttime
    } fångst {
        $lastBootTime = $null
    }
    if ($lastBootTime) { Write-Host "Last Boot Time: $lastBootTime" } else { Write-Host "Last Boot Time: Not Available" }
}

# 28. BaseBoardManufacturer
# PS-version: 3.0+ (använd Get-WmiObject för 2.0) | Admin: Nej | Systemkrav: Inga
prova {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Manufacturer)) {
        Write-Warning "Det gick inte att hämta baseboardtillverkaren"
        $baseBoardManufacturer = "Okänd"
    } annars {
        $baseBoardManufacturer = $baseBoard.Manufacturer
    }
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
} fångst {
    # CIM kan misslyckas - baseboard-information är kompletterande
    $baseBoardManufacturer = "Okänd"
    Write-Host "Baseboard Manufacturer: $baseBoardManufacturer"
}

# 29. BaseBoardProduct
# PS-version: 3.0+ (använd Get-WmiObject för 2.0) | Admin: Nej | Systemkrav: Inga
prova {
    $baseBoard = Get-CimInstance Win32_BaseBoard -ErrorAction Stop
    if ($null -eq $baseBoard -or [string]::IsNullOrEmpty($baseBoard.Product)) {
        Write-Warning "Det gick inte att hämta baseboard-produkt"
        $baseBoardProduct = "Okänd"
    } annars {
        $baseBoardProduct = $baseBoard.Product
    }
    Write-Host "Baseboard-produkt: $baseBoardProduct"
} fångst {
    # CIM kan misslyckas - baseboard-information är kompletterande
    $baseBoardProduct = "Okänd"
    Write-Host "Baseboard Product: $baseBoardProduct"
}

# 30. SecureBootTaskEnabled
# PS-version: Alla | Admin: Nej | Systemkrav: Schemalagd aktivitet finns
# Kontrollerar om den schemalagda uppgiften Secure-Boot-Update är aktiverad
$secureBootTaskEnabled = $null
$secureBootTaskStatus = "Okänd"
prova {
    $taskOutput = schtasks.exe /Query /TN "\Microsoft\Windows\PI\Secure-Boot-Update" /FO CSV 2>&1
    if ($LASTEXITCODE -eq 0) {
        $taskData = $taskOutput | KonverteraFrom-Csv
        if ($taskData) {
            $secureBootTaskStatus = $taskData.Status
            $secureBootTaskEnabled = ($taskData.Status -eq 'Ready' -eller $taskData.Status -eq 'Running')
        }
    } annars {
        $secureBootTaskStatus = "NotFound"
        $secureBootTaskEnabled = $false
    }
    if ($secureBootTaskEnabled -eq $false) {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -ForegroundColor Yellow
    } annars {
        Write-Host "SecureBoot Update Task: $secureBootTaskStatus (Enabled: $secureBootTaskEnabled)" -ForegroundColor Green
    }
} fångst {
    $secureBootTaskStatus = "Fel"
    $secureBootTaskEnabled = $false
    Write-Host "SecureBoot Update Task: Felkontroll - $_" -ForegroundColor Red
}

# 31. WinCS-nyckelstatus (F33E0C8E002 – säker startcertifikatuppdatering)
# PS-version: Alla | Admin: Ja (för fråga) | Systemkrav: WinCsFlags.exe
$wincsKeyApplied = $null
$wincsKeyStatus = "Okänd"
prova {
    # Kontrollera vanliga platser för WinCsFlags.exe
    $wincsFlagsPath = $null
    $possiblePaths = @(
        "$env:SystemRoot\System32\WinCsFlags.exe",
        "$env:SystemRoot\SysWOW64\WinCsFlags.exe"
    )
    foreach ($p i $possiblePaths) {
        if (Test-Path $p) { $wincsFlagsPath = $p; break }
    }

    om ($wincsFlagsPath) {
        # Frågespecifik nyckel – kräver administratörsrättigheter
        $queryOutput = & $wincsFlagsPath /query --key F33E0C8E002 2>&1
        $queryOutputStr = $queryOutput -join "'n"

        if ($LASTEXITCODE -eq 0) {
            # Kontrollera om nyckeln används (leta efter "Aktiv konfiguration" eller liknande indikator)
            if ($queryOutputStr -match "Active Configuration.*:.*enabled" -or $queryOutputStr -match "Configuration.*applied") {
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Används"
                Write-Host "WinCS-tangenten F33E0C8E002: Används" -FörgrundFärg grön
            } elseif ($queryOutputStr -match "hittades inte|Ingen konfiguration") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS-tangenten F33E0C8E002: Inte tillämpad" -FörgrundFärg gul
            } annars {
                # Key exists - check output for state
                $wincsKeyApplied = $true
                $wincsKeyStatus = "Används"
                Write-Host "WinCS-tangenten F33E0C8E002: Tillämpas" -FörgrundFärg grön
            }
        } annars {
            # Sök efter specifika felmeddelanden
            if ($queryOutputStr -match "Access denied|administrator") {
                $wincsKeyStatus = "AccessDenied"
                Write-Host "WinCS-nyckel F33E0C8E002: Access denied (run as admin)" -ForegroundColor DarkGray
            } elseif ($queryOutputStr -match "hittades inte|Ingen konfiguration") {
                $wincsKeyApplied = $false
                $wincsKeyStatus = "NotApplied"
                Write-Host "WinCS-tangenten F33E0C8E002: Inte tillämpad" -FörgrundFärg gul
            } annars {
                $wincsKeyStatus = "QueryFailed"
                Write-Host "WinCS-tangenten F33E0C8E002: Frågan misslyckades" -ForegroundColor Red
            }
        }
    } annars {
        $wincsKeyStatus = "WinCsFlagsNotFound"
        Write-Host "WinCS-tangenten F33E0C8E002: WinCsFlags.exe hittades inte" -ForegroundColor Gray
    }
} fångst {
    $wincsKeyStatus = "Fel"
    Write-Host "WinCS-tangenten F33E0C8E002: Felkontroll - $_" -ForegroundColor Red
}              

# =============================================================================
# Identifiering av åtgärd – statusutdata & utgångskod
# =============================================================================

# Skapa statusobjekt från alla insamlade lagerdata
$status = [beställt]@{
    UEFICA2023Status = $uefica 2023Status
    UEFICA2023Fel = $uefica 2023Fel
    UEFICA2023ErrorEvent = $uefica 2023ErrorEvent
    AvailableUpdates = if ($null -ne $availableUpdates) { $availableUpdatesHex } else { $null }
    AvailableUpdatesPolicy = if ($null -ne $availableUpdatesPolicy) { $availableUpdatesPolicyHex } else { $null }
    Hostname = $hostname
    CollectionTime = if ($collectionTime -is [datetime]) { $collectionTime.ToString("o") } else { "$collectionTime" }
    SecureBootEnabled = $secureBootEnabled
    HighConfidenceOptOut = $highConfidenceOptOut
    MicrosoftUpdateManagedOptIn = $microsoftUpdateManagedOptIn
    OEMManufacturerName = $oemManufacturerName
    OEMModelSystemFamily = $oemModelSystemFamily
    OEMModelNumber = $oemModelNumber
    FirmwareVersion = $firmwareVersion
    FirmwareReleaseDate = $firmwareReleaseDate
    OSArchitecture = $osArchitecture
    CanAttemptUpdateAfter = om ($canAttemptUpdateAfter -är [datumtid]) { $canAttemptUpdateAfter.ToString("o") } annars { "$canAttemptUpdateAfter" }
    LatestEventId = $latestEventId
    BucketId = $bucketId
    Confidence = $confidence
    SkipReasonKnownIssue = $skipReasonKnownIssue # KI_<nummer> från SkipReason i BucketId-händelse
    Event1801Count = $event 1801Count
    Event1808Count = $event 1808Count
    # Felhändelser med insamlad information
    Event1795Count = $event 1795Count # Firmware returnerade fel
    Event1795ErrorCode = $event 1795ErrorCode # Felkod från inbyggd programvara
    Event1796Count = $event 1796Count # Felkod loggad
    Event1796ErrorCode = $event 1796ErrorCode # Felkod
insamlad     Event1800Count = $event 1800Count # Reboot needed (NOT an error)
    RebootPending = $rebootPending # True if Event 1800 present
    Event1802Count = $event 1802Count # Problem med känd inbyggd programvara
    KnownIssueId = $knownIssueId # KI_<nummer> från SkipReason
    Event1803Count = $event 1803Count # Missing KEK update
    MissingKEK = $missingKEK # OEM behöver leverera PK signerad KEK
    OSVersion = $osVersion
    LastBootTime = if ($lastBootTime -is [datetime]) { $lastBootTime.ToString("o") } else { "$lastBootTime" }
    BaseBoardManufacturer = $baseBoardManufacturer
    BaseBoardProduct = $baseBoardProduct
    SecureBootTaskEnabled = $secureBootTaskEnabled
    SecureBootTaskStatus = $secureBootTaskStatus
    WinCSKeyApplied = $wincsKeyApplied # True om F33E0C8E002 nyckel används
    WinCSKeyStatus = $wincsKeyStatus # Applied, NotApplied, WinCsFlagsNotFound o.s.v.
}

# Mata ut statusen – För dataaggregering
$jsonOutput = $status | ConvertTo-Json -Compress

# Om OutputPath tillhandahålls sparar du filen; annars utdata till stdout
if (-not [string]::IsNullOrEmpty($OutputPath)) {
    # Verifiera OutputPath – hoppa över om det ser ut som en hjälpbegäran eller har ogiltiga tecken
    if ($OutputPath -match '^[/\-]' -eller $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 }
    }
    
    # Kontrollera att utdatamappen finns
    if (-not (Test-Path $OutputPath)) {
        prova {
            New-Item -ItemType Directory -Path $OutputPath -Force | Out-Null
        } fångst {
            Write-Warning "Det gick inte att skapa utdatamapp: $OutputPath – $_"
        }
    }
    
    # Spara i HOSTNAME_latest.json
    $outputFile = Join-Path $OutputPath "$($hostname)_latest.json"
    prova {
        $jsonOutput | Out-File -FilePath $outputFile -Kodning UTF8 -Force
        Write-Host "JSON saved to: $outputFile" -ForegroundColor Green
    } fångst {
        Write-Warning "Det gick inte att skriva till filen: $outputFile - $_"
        # Fall tillbaka till stdout
       
Write-Output $jsonOutput     }
} annars {
    # Ursprungligt beteende – utdata till stdout
   
Write-Output $jsonOutput }

# Utgångskod: "Uppdaterad" är framgångsvärdet per spelbok
if ($secureBootEnabled -and $uefica 2023Status -eq "Uppdaterad") {
    exit 0 # Utan problem
} annars {
    exit 1 # Med problem
}