Exempel på Detect-SecureBootCertUpdateStatus.ps1 skript

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

.DESCRIPTION     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.

    Compatible with Intune Remediations, GPO-based collection, and other management tools.
Inget åtgärdsskript behövs – det här är endast övervakning.

    Exit 0 = "Without issue"  (certificates updated)     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).

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

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

.NOTES     Registersökvägar 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     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
)

# Download 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. HostName
# 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 values)

# 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-controlled persistent value)
# 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 values)

# 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. UEFICA2023Error
# 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 values: 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"
}

# Event Logs: System Log (10 values: 16-25)

# 16-25. Event Log queries
# 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)

    if ($events.Count -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 - Extracted from Event 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. Confidence - Extracted from Event 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 - Extract KI_<number> from SkipReason in the same event as 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 Queries (5 values)

# 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 Key Status (F33E0C8E002 - Secure Boot Certificate Update)
# 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
# =============================================================================

# Build status object from all collected inventory data $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.
}

# Output the status - For data aggregation $jsonOutput = $status | ConvertTo-Json -Compress

# If OutputPath provided, save to file; otherwise output to 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 }          

# Exit code: "Updated" is the success value per the playbook if ($secureBootEnabled -and $uefica 2023Status -eq "Uppdaterad") {
    exit 0 # Utan problem
} annars {
    exit 1 # Med problem
}