Secure_Boot_Certificates_Checks

Secure Boot Certificates 2026 Deadline: How to Check Device Compliance

Secure Boot is about to undergo its biggest change in over a decade. For years, the same digital certificates have safeguarded the Windows boot process. But beginning this June, that stability ends. Microsoft is rolling out new 2023 certificates to replace the ageing keys that have been in place since Windows Server 2012.

For IT teams, this isn’t a warning about failing hardware—it’s a critical maintenance deadline. Missing these updates won’t cause systems to crash, but it will create a long-term security blind spot. Any device without the new keys can no longer receive boot-level security fixes, instantly falling out of compliance.

Here’s what you need to know to ensure your transition is seamless.

What is UEFI?

UEFI is the modern firmware that replaced the “legacy BIOS.” It starts the machine, then hands off to the operating system.

What is Secure Boot?

Secure Boot is a UEFI feature that only allows trusted, signed boot components to run early in startup. It works using a chain of trust:

  • PK (Platform Key) – top of the trust chain, usually controlled by the OEM
  • KEK (Key Exchange Key) – controls updates to the signature databases
  • DB (Allowed signatures) – what is allowed to boot
  • DBX (Revoked signatures) – what is blocked, even if otherwise valid

Where is that trust stored?

In the firmware itself, inside UEFI Secure Boot variables (PK/KEK/DB/DBX). Microsoft’s certificates live primarily in DB and KEK, depending on the certificate

Only Microsoft-trusted (or OEM-trusted) code is allowed

What’s expiring, and what replaces it?

Here’s the core mapping (the one you’ll keep coming back to):

Expiring certificateExpiration dateNew certificateStorage locationPurpose
Microsoft Corporation KEK CA 2011June 25, 2026Microsoft Corporation KEK 2K CA 2023Stored in KEK, KEKDefaultSigns updates to db and dbx.
Microsoft Windows Production PCA 2011October 20, 2026Windows UEFI CA 2023Stored in db, dbDefaultUsed for signing the Windows boot loader.
Microsoft UEFI CA 2011June 28, 2026Microsoft UEFI CA 2023Stored in db, dbDefaultSigns third-party boot loaders and EFI applications.
Microsoft UEFI CA 2011June 28, 2026Microsoft Option ROM UEFI CA 2023Stored in db, dbDefaultSigns third-party option ROMs (for example, networking or graphics cards).

The Microsoft Corporation KEK 2K CA 2023 and Windows UEFI CA 2023 certificates are enabled by default and are automatically updated on all applicable systems.

The Microsoft UEFI CA 2023 and Microsoft Option ROM UEFI CA 2023 certificates are not enabled by default on PCs that comply with recent versions of the Microsoft Secured-core PC requirements. If you do not intend to use third-party UEFI code, HP recommends leaving these certificates disabled.

The Enable MS UEFI CA Key setting controls third-party UEFI certificates. To locate this option, open the F10 BIOS Setup menu.


How Microsoft delivers the updates (so you don’t over-engineer it)

Microsoft’s guidance is basically:

  1. Many devices (especially manufactured since 2024) already have 2023 certs.
  2. For the rest, Microsoft can deploy via monthly Windows updates for “high-confidence” device types, unless you opt out.
  3. OEM firmware updates can be important because they enable the firmware to accept and store new certificates. Apply OEM firmware updates first if recommended.
  4. If you want to deploy yourself proactively, you can trigger the process using registry keys (and there are Intune+ GPO options too)

Tip: Don’t mix deployment methods on the same device (registry vs GPO vs Intune), especially during pilots.


PowerShell: One script to check everything (“Am I safe for June 2026?”)

I created a detection and remediation script to help you assess compliance across your tenant device fleet. You can find both scripts on GitHub.

If you want to learn how to deploy them using Microsoft Intune, see my post: How to Deploy PowerShell Script via Intune: A Complete Guide for IT Admins.

What the detection script checks

  • Secure Boot is enabled
    • If SecureBootOn is false, nothing else matters.
  • Registry status and errors
    • UEFICA2023Status should be updated
    • UEFICA2023Error should be null/0 (key shouldn’t be present unless an error is pending)
  • Event log proof (the fastest truth source), Microsoft’s playbook says:
    • Event ID 1808 indicates that the required new certificates have been applied to the firmware
    • Event ID 1801 indicates updated certificates have not been applied yet
  • Firmware rejection signals
    • If you see 1795 events, Microsoft explains this is firmware returning an error while updating Secure Boot variables, and Windows will retry on the next restart. The action is to check with the OEM for firmware updates.

How to read the detection output quickly

  • SafeForJune2026
    • true = compliant (exit 0)
    • false = not compliant (exit 1)
  • If false, read only:
    • ComplianceReasons
    • ComplianceDetails
  • Two common real-world interpretations
    • UEFICA2023Status = NotStarted/InProgress → The device hasn’t finished; remember the 12-hour task cadence and reboot dependency.
    • Event 1795 → firmware rejected the handoff; prioritise OEM BIOS/UEFI update
  • FirmwareState = Applied When the Event ID 1808 is the newest
  • FirmwareState = Pending When the Event ID 1801 is the newest

Tip: Run the script as administrator for best results—event log access and some firmware-related signals are more reliable with elevated permissions

This script is designed for Intune Detection. If you want to test it on a machine, make sure to comment out the last lines

($safe) {
exit 0
} else {
exit 1
}

The output would be compress json, which you can do by simply commenting out the compression option

$summary | ConvertTo-Json -Depth 10 #-Compress

What the remediation script does

Step 0 — Pre-flight checks (and early exit)

It captures PreState (Secure Boot, registry status, and relevant TPM-WMI events), then:

  • If Secure Boot isn’t on → exits 1 with clear NextSteps
  • If the firmware is already Applied and there’s no servicing error → exits 0 immediately

That makes it safe to run repeatedly across a fleet.

Step 1 — Set the enterprise trigger: AvailableUpdates = 0x5944

The script writes:

  • HKLM:\SYSTEM\CurrentControlSet\Control\SecureBoot\AvailableUpdates = 0x5944

This matches Microsoft’s enterprise guidance for deploying all needed components.

Step 2 — Run the scheduled task now (don’t wait 12 hours)

It then runs the task at:

  • \Microsoft\Windows\PI\Secure-Boot-Update

The script also waits briefly and captures LastTaskResult to help with troubleshooting.

Step 3 — Suspend BitLocker for two reboots (practical protection)

Firmware/boot-chain changes can trigger BitLocker recovery prompts in some environments. Your script attempts:

  • Suspend-BitLocker -RebootCount 2 (with a manage-bde fallback)

It reports whether suspension was attempted and whether it succeeded, so the service desk isn’t blindsided.

Step 4 — Post-check and a human answer

It gathers PostState and decides:

  • Completed (exit 0) if firmware is Applied and UEFICA2023Error is clear
  • NotCompleted (exit 1) with tailored NextSteps if:
    • Firmware is Pending (often means “reboot required”)
    • Firmware state is Unknown (logs missing/inconclusive)
    • Registry/task execution failed
    • Firmware errors exist (1795–1798 family)

How to read the remediation output quickly

Start with:

  • Status (Completed / NotCompleted)
  • Reason (single paragraph you can paste into a ticket)
  • NextSteps (what the user/IT must do next)

Then, only if needed:

  • Actions (what it tried: reg set, task start, BitLocker suspend)
  • PreState and PostState (before/after evidence)

The most common “NotCompleted” case you’ll see

FirmwareState = Pending → your script correctly advises reboot(s), then re-run detection to confirm Event 1808 appears. Microsoft notes the boot manager update may not occur until after a restar

The rollout plan that won’t ruin your week

1) Baseline report (before changing anything)

Use detection output to segment:

  • Secure Boot off (fix BIOS policy/device configuration)
  • NotStarted/InProgress (time + reboot + patience)
  • Pending (1801 newest → needs reboot/follow-up)
  • Firmware rejection (1795+ → OEM firmware update queue)

2) Patch and firmware first on problem models

Microsoft explicitly recommends applying OEM firmware updates first if you’ve identified Secure Boot update issues or OEM recommends it.

3) Pilot the remediation script via Intune Proactive Remediations

Typical flow:

  • Detection runs → if exit 1, remediation runs
  • Remediation triggers update and returns next steps
  • After reboot cycle → detection should return SAFE

4) Monitor using the same signals Microsoft tells you to use

  • UEFICA2023Status = Updated
  • No UEFICA2023Error
  • Event ID 1808 presents as success proof

Troubleshooting cheat sheet (copy into your runbook)

UEFICA2023Status = NotStarted / InProgress

  • Normal during rollout; task runs every 12 hours; reboot may be needed.
    ✅ Action: wait, reboot, re-run detection

UEFICA2023Error is non-zero

  • Indicates a fault; Microsoft advises checking Secure Boot events for root cause.
    ✅ Action: review TPM-WMI events 1795–1799; prioritise OEM firmware if firmware errors appear

Event 1801 (newest)

  • Updated certificates not applied yet.
    ✅ Action: reboot and re-check until 1808 appears

Event 1795

  • Firmware returned an error when updating Secure Boot variables; Windows retries on next restart; OEM firmware update recommended.
    ✅ Action: update BIOS/UEFI firmware, reboot, retry remediation

FAQ

Will devices stop booting in June 2026?

Microsoft’s risk statement focuses on loss of boot-component security updating after certificate expiry and devices becoming out of security compliance if not updated before expiration.

How do I prove a device is updated?

Microsoft’s playbook calls out:

  • Event 1808 (success proof)
  • UEFICA2023Status = Updated
  • no UEFICA2023Error

7 Comments

  1. Johan

    Perhaps a stupid question, but does this require that the servers have internet access to be updated?
    Or is everything needed included in the monthly cumulative security updates?

  2. I didn’t try this but I would assume you can

    1 – Verify the minimum supported BIOS/UEFI version (per the OEM) that allows Windows to write the updated Secure Boot certificate/DBX variables.

    2 – Suspend BitLocker protection, then install the latest OEM firmware/BIOS update.

    3 -Ensure the February 2024 cumulative update (or any later cumulative update) is installed on the device.

    Restart the machine, then run the detection script to confirm what’s still required. You may also need to set the relevant registry key, which is included in the remediation script.

  3. Pieter P

    Great blog post. A few things missing I want to add:
    1) There’s a minimum Windows OS patch level required for the automated cert installation to work. Computers stuck on a patch level before that just get stuck in status NotStarted.
    https://support.microsoft.com/en-us/topic/group-policy-objects-gpo-method-of-secure-boot-for-windows-devices-with-it-managed-updates-65f716aa-2109-4c78-8b1f-036198dd5ce7
    2) Sometimes the Secure Boot update process gets into error due to seemingly random issues, such as Bitlocker drive encryption running, Secure Boot not being enabled in the firmware, wrong UEFI firmware version, reboot pending,…
    3) Some vendors have BIOS settings that prevent UEFI updates from Windows, like Lenovo. Those settings need to be set correctly before doing any firmware updates or changes. https://support.lenovo.com/us/en/solutions/ht510603-applying-bios-updates-with-lenovo-patch
    4) Check out the vendor lists of minimum firmware versions required to find out which UEFI versions on which HW models are gonna be problematic. Only Lenovo hasn’t released their list yet as far as I know. Others have, like HP, Dell, Microsoft,…
    5) Microsoft Update Catalog doesn’t provide the latest firmware versions provided by the OEM vendors. Better stick with updating manually if you require the most recent version to be compatible.

  4. Thanks! Really useful additions.

    1) Agreed, there’s a minimum Windows patch level for the automated cert install; older builds can sit at NotStarted (will update the script with that)

    2) Yes, random blockers happen (BitLocker activity, Secure Boot disabled, UEFI/firmware mismatch, pending reboot, etc.). This should be handled by the detection/pre-check script, but I agree we should dig deeper into the other failure scenarios.

    3–5) Agree, OEM BIOS settings (e.g., Lenovo), vendor minimum firmware lists, and the Update Catalog not always having the latest OEM firmware are all worth calling out. I’ll add these notes to the post.

  5. Gerolf Holenia

    Hi

    Thanks for the Upload. I tried it out on my Laptop and in our systems it seems to be working.

    Maybe worth checking. Event ID 1802 shows on my Computer what the issue is with the 1801 ID.

    1801 Message:
    Secure Boot certificates have been updated but are not yet applied to the device firmware. Review the published guidance to complete the update and ensure full protection. This device signature information is included here.
    DeviceAttributes: FirmwareManufacturer:HP;FirmwareVersion:V70 Ver. 01.09.00;OEMModelBaseBoard:8B41;OEMManufacturerName:HP;OSArchitecture:amd64;

    1802 Message:
    The Secure Boot update KEK 2023 was blocked due to a known firmware issue on the device. Check with your device vendor for a firmware update that addresses the issue. This device signature information is included here.
    DeviceAttributes: FirmwareManufacturer:HP;FirmwareVersion:V70 Ver. 01.09.00;OEMModelBaseBoard:8B41;OEMManufacturerName:HP;OSArchitecture:amd64;

    • Gerolf Holenia

      Here the change in the script:

      try {
      $tpmEvents = Get-WinEvent -FilterHashtable @{
      LogName = “System”
      Id = 1795,1796,1797,1798,1799,1801,1802,1808
      } -MaxEvents 200 -ErrorAction SilentlyContinue |
      Where-Object { $_.ProviderName -eq “Microsoft-Windows-TPM-WMI” }

      if ($tpmEvents) {
      $latest1808 = $tpmEvents | Where-Object { $_.Id -eq 1808 } | Sort-Object TimeCreated -Descending | Select-Object -First 1
      $latest1801 = $tpmEvents | Where-Object { $_.Id -eq 1801 } | Sort-Object TimeCreated -Descending | Select-Object -First 1
      $latest1801 = $tpmEvents | Where-Object { $_.Id -eq 1802 } | Sort-Object TimeCreated -Descending | Select-Object -First 1

      $latestFailure = $tpmEvents | Where-Object { $_.Id -in 1795,1796,1797,1798,1799 } |
      Sort-Object TimeCreated -Descending | Select-Object -First 1

      $latestTpm = $tpmEvents | Sort-Object TimeCreated -Descending | Select-Object -First 1
      }
      } catch {}

      $LatestEvent1808 = if ($latest1808) { $latest1808.TimeCreated.ToString(“o”) } else { $null }
      $LatestEvent1801 = if ($latest1801) { $latest1801.TimeCreated.ToString(“o”) } else { $null }
      $LatestEvent1802 = if ($latest1802) { $latest1802.TimeCreated.ToString(“o”) } else { $null }

      $latestFailureTime = if ($latestFailure) { $latestFailure.TimeCreated.ToString(“o”) } else { $null }
      $latestFailureEventId = if ($latestFailure) { $latestFailure.Id } else { $null }

      # Firmware state from events:
      $firmwareApplied = $false
      $firmwarePending = $false
      $firmwareState = “Unknown”

      if ($latest1808 -and
      (-not $latest1801 -or $latest1808.TimeCreated -ge $latest1801.TimeCreated) -and
      (-not $latest1802 -or $latest1808.TimeCreated -ge $latest1802.TimeCreated)) {

      $firmwareApplied = $true
      $firmwareState = “Applied”
      }
      elseif ($latest1801 -and
      (-not $latest1808 -or $latest1801.TimeCreated -gt $latest1808.TimeCreated) -and
      (-not $latest1802 -or $latest1801.TimeCreated -ge $latest1802.TimeCreated)) {

      $firmwarePending = $true
      $firmwareState = “Pending”
      $firmwareNotAppliedReason = Get-FirstLine -Text $latest1801.Message
      }
      elseif ($latest1802) {
      $firmwareApplied = $false
      $firmwarePending = $false
      $firmwareState = “Failed”
      $firmwareNotAppliedReason = Get-FirstLine -Text $latest1802.Message
      }

Leave a Reply

Your email address will not be published. Required fields are marked *