HomeNewsletterCommunityMVP FeedToolsArchiveBlogToday's NewsAboutServicesQuick Links Subscribe free
← Back to Blog
Windows 11 Windows 11VBSCredential GuardMemory IntegrityDevice GuardIntuneGroup PolicyTroubleshooting

Virtualisation-based security will not start: the firmware, hypervisor and licensing prerequisites in the order Windows checks them

IA
Imran Awan
21 August 2026

You push a policy to turn on Memory Integrity, or Credential Guard, or System Guard Secure Launch. A week later the compliance report says a few hundred machines still have it off. You remote onto one, open Windows Security, go to Device security, and the toggle is either off, or greyed out, or says it is managed by your administrator. Nothing on that screen tells you why. So somebody starts turning things off at random: Secure Boot, the policy itself, the Hyper-V feature, a driver. That is how a one-line firmware problem turns into a three-day outage.

The short version

Virtualisation-based security (VBS) is the hypervisor-backed memory boundary that Credential Guard, Memory Integrity and Secure Launch live inside. It is not a virtual machine and it does not need the Hyper-V role. When it will not start, Windows has already walked a fixed prerequisite chain and failed at exactly one link: processor virtualisation extensions and SLAT, then UEFI plus Secure Boot, then the policy itself, then the platform security level, then the hypervisor launch type in the BCD store. Win32_DeviceGuard tells you which link broke if you can read its five enumerations, and the two that catch most fleets are a platform security level demanding DMA protection the hardware does not have, and hypervisorlaunchtype left at Off by an old performance tweak.

The problem: the Settings UI knows and will not tell you

The symptoms all look different and all have the same root. Here is what lands in the ticket queue.

All six are the same sentence: something below the feature did not start. VBS is that something. Every one of those features is a tenant inside VBS. If the building does not open, no tenant opens either, and the Settings page only ever reports on the tenant.

What VBS actually is, in one paragraph. Microsoft's definition is precise and worth reading slowly: VBS "uses hardware virtualization and the Windows hypervisor to create an isolated virtual environment that becomes the root of trust of the OS that assumes the kernel can be compromised." Read that again. It is not a virtual machine you log into. It is a second, smaller memory world sitting beside normal Windows, created by the same hypervisor that Hyper-V uses, but hosting a handful of security processes instead of a guest operating system. Windows itself, kernel included, cannot reach into that world. That is the whole point: the design assumes an attacker already owns your kernel, and puts the secrets somewhere the kernel cannot follow.

Two consequences fall straight out of that definition, and both surprise people.

First, VBS needs the Windows hypervisor, which means it needs the same processor features a hypervisor needs. Second, VBS does not need the Hyper-V role. You do not install a Windows feature to get VBS. The hypervisor is loaded by the boot loader before Windows starts, whether or not you ever create a virtual machine. People uninstall the Hyper-V optional feature expecting VBS to survive, and it does. People disable the hypervisor in the boot configuration expecting only Hyper-V to stop, and VBS dies with it.

Why it happens: the prerequisite chain in evaluation order

Windows checks the prerequisites in a fixed order during boot. Knowing that order is the entire diagnostic technique, because a failure at link three makes every check after it meaningless.

The boot chain, file by file

These are the binaries involved, in the order they run. Every one lives in C:\Windows\System32 on a client install.

Parent path for every file below: C:\Windows\System32\
BinaryWhat it does in the VBS flow
winload.efiThe Windows OS loader. Reads the boot entry out of the BCD store, and it is the code that decides whether to bring the hypervisor up at all.
hvloader.dllThe hypervisor loader. Picks and loads the correct hypervisor image for the processor family.
hvix64.exeThe hypervisor image used on Intel processors with VT-x.
hvax64.exeThe hypervisor image used on AMD processors with AMD-V. On Arm64 the equivalent is hvaa64.exe.
securekernel.exeThe secure kernel. This is the operating system of the isolated region, and it is what "the secure kernel is not running" in the event log refers to.
skci.dllSecure kernel code integrity. This is the module that performs kernel-mode code integrity checks inside the isolated region, which is what makes Memory Integrity hypervisor-enforced rather than just kernel-enforced.
ci.dllThe normal-world code integrity module. Still present and still used; skci.dll does not replace it.
lsaiso.exeThe isolated LSA process. This is the tenant Credential Guard puts inside VBS. Microsoft is explicit that checking Task Manager for this process is not a recommended way to test Credential Guard.

Only one of hvix64.exe and hvax64.exe is needed on any given machine, so seeing one of the pair missing is normal, not a fault.

The nine links, in the order they are evaluated

LinkWhat must be trueWhat it looks like when this link is the failure
164-bit Windows. Microsoft states VBS requires the Windows hypervisor, "which is only supported on 64-bit IA processors with virtualization extensions".Nothing VBS-related appears anywhere. There is no software fix.
2Processor virtualisation extensions (Intel VT-x, AMD-V) and Second Level Address Translation, either Intel EPT or AMD RVI.AvailableSecurityProperties does not contain 1. msinfo32 omits "Base Virtualization Support".
3UEFI firmware, and Secure Boot enabled. Microsoft states Secure Boot "must be enabled on devices leveraging VBS".AvailableSecurityProperties does not contain 2. Classic on machines converted from MBR to GPT that still boot with CSM active.
4A policy actually asking for VBS, or the default-enablement path on Windows 11 22H2 and later.VirtualizationBasedSecurityStatus is 0. Nothing is broken; nothing is asking.
5Every property named in RequiredSecurityProperties must also appear in AvailableSecurityProperties.VirtualizationBasedSecurityStatus is 1, enabled but not running. This is the big one.
6hypervisorlaunchtype in the boot entry must not be Off.Also status 1, enabled but not running, and completely immune to policy changes.
7The loader chain binaries above must exist and be intact.Boot failure, or status 1. Usually component-store damage or a "debloat" script.
8The hypervisor and secure kernel actually launch.Status 1, with Wininit event 15 in the System log naming the secure kernel.
9Each hosted service must be permitted and supported.VBS status 2, but SecurityServicesConfigured lists something that is absent from SecurityServicesRunning.

The hardware and firmware requirements, and which are hard

Microsoft publishes a requirements table for VBS. It is worth separating the items that block VBS outright from the items that are guidance to OEMs.

RequirementMicrosoft's wording, condensedBlocks VBS?
64-bit CPU with virtualisation extensionsIntel VT-x or AMD-V, on 64-bit IA processors.Yes, absolutely
Second Level Address TranslationIntel VT-x2 with Extended Page Tables, or AMD-V with Rapid Virtualization Indexing.Yes, absolutely
Secure Boot"Secure Boot must be enabled on devices leveraging VBS."Yes
IOMMU or SMMU (Intel VT-d, AMD-Vi, Arm64 SMMU)"All I/O devices capable of DMA must be behind an IOMMU or SMMU. An IOMMU can be used to enhance system resiliency against memory attacks."Only if you ask for it (see the platform security level below)
TPM 2.0Listed as a component in the VBS requirements table, with a pointer to the separate TPM 2.0 requirements page. Note that Microsoft's Credential Guard hardware requirements page does not list TPM at all - its table names Secure Boot, Secure Boot configuration and management, a secure firmware update process, UEFI, and VBS itself.Not the thing that blocks base VBS in practice; it is what makes measured and sealed scenarios such as Secure Launch possible
Firmware SMM protection (WSMT)Firmware must implement the Windows SMM Security Mitigations Table protections and report compliance.Surfaces as property 6 rather than as a hard block
UEFI Memory Attributes Table, v2.6Firmware must cleanly separate EFI runtime code and data ranges, page-aligned, with read-only or execute-protect attributes.Only if you switch on "Require UEFI Memory Attributes Table"
Secure Memory Overwrite Request v2Protects the MOR lock setting using a UEFI secure variable.Surfaces as property 4

Gotcha: the platform security level is where careful admins break their own fleet. The setting is called Select Platform Security Level in Group Policy and RequirePlatformSecurityFeatures in the registry and CSP. Value 1 means Secure Boot. Value 3 means Secure Boot and DMA protection. Three looks stronger, so people pick it. Microsoft's own warning is blunt: if you select Secure Boot with DMA, "memory integrity and the other VBS features will only be turned on for computers that support DMA. That is, for computers with IOMMUs only. Any computer without IOMMUs will not have VBS or memory integrity protection." A mixed fleet given value 3 silently loses VBS on every older or cheaper machine. Microsoft recommends value 1 in most situations, because it gives each machine as much protection as its own hardware supports rather than excluding the weaker half.

The hypervisor launch type

The Boot Configuration Data store holds a per-boot-entry option called hypervisorlaunchtype. Microsoft documents exactly two values: Off and Auto. Auto is the shipping default. Off tells the OS loader not to launch the hypervisor. There is a matching option, vsmlaunchtype, with the same two values, which controls Virtual Secure Mode specifically.

This single value has caused more silent VBS failures than any hardware fault, because a decade of performance guides, game anti-cheat advice and forum posts all end with the same instruction: run bcdedit /set hypervisorlaunchtype off. Users run it. Imaging scripts inherit it. Reference images carry it. And a machine with that value set will report VBS as enabled but not running forever, regardless of how many policies you push at it, because policy is evaluated after the loader has already declined to start the hypervisor.

Destructive risk: two settings here can stop a device booting. The first is Mandatory under Control\DeviceGuard. Microsoft's own words: "The Mandatory setting prevents the OS loader from continuing to boot in case the Hypervisor, Secure Kernel or one of their dependent modules fails to load", and "in case of any failure of the virtualization modules, the system will refuse to boot". Do not push that to a fleet to force compliance. The second is UEFI lock. Locked set to 1, or any of the "Enabled with UEFI lock" dropdown choices, persists the setting in firmware variables. Removing the policy afterwards does not remove it from the device. Undoing a UEFI-locked Credential Guard configuration requires a documented SecConfig.efi boot-sequence procedure and someone physically present at the keyboard to press a key and accept the change. If you might ever need to turn it off remotely, choose "Enabled without lock". Separately: changing any boot entry alters the measured boot state, so suspend BitLocker for one reboot before touching bcdedit or you will be reading recovery keys to users over the phone.

The licensing and edition angle

This one confuses people because the answer is different for VBS and for the things inside it.

Microsoft's Windows security licensing and edition reference lists Virtualization-based security (VBS) as supported on Windows Pro, Windows Enterprise, Windows Pro Education and Windows Education, and available under Pro licensing as well as Enterprise E3/E5 and Education A3/A5. The same is true of Hypervisor-protected Code Integrity. So there is no edition gate on VBS itself, and no edition gate on Memory Integrity.

Credential Guard is different. The same reference marks it unsupported on Windows Pro and Windows Pro Education, and supported only on Enterprise and Education. The DeviceGuard CSP reference agrees and goes further: the EnableVirtualizationBasedSecurity node is listed for Pro, Enterprise, Education and IoT Enterprise, but RequirePlatformSecurityFeatures and LsaCfgFlags are listed for Enterprise, Education and IoT Enterprise only, with Pro explicitly excluded.

The practical effect: push a single Device Guard profile to a mixed fleet and the Pro machines will accept the VBS switch and quietly ignore the Credential Guard part. That reads on the device as Credential Guard configured but not running, which looks exactly like a hardware failure and is not one.

How to verify: reading which link actually failed

There are five places to look, and they answer different questions. Take them in this order.

1. Win32_DeviceGuard, and how to read all five enumerations

This is the authoritative source. It is a WMI class in its own namespace, and Microsoft's guidance is to query it from an elevated PowerShell session. The command below returns one instance describing both what the hardware can do and what is currently running.

PowerShell - run elevated
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard # The class needs an elevated session. Non-elevated it usually throws, and an # empty result is NOT the same as "VBS is off" - it means the read failed. AvailableSecurityProperties : {1, 2, 3, 4, 5, 6, 7} RequiredSecurityProperties : {1, 2, 3} SecurityServicesConfigured : {1, 2, 3, 4} SecurityServicesRunning : {1, 2, 3, 4} VirtualizationBasedSecurityStatus : 2 CodeIntegrityPolicyEnforcementStatus : 2 SmmIsolationLevel : 30 # HEALTHY: status 2 means enabled AND running. Every number in Required also # appears in Available. Configured and Running are identical lists. # BROKEN would be status 1, or a number in Required missing from Available, # or a number in Configured that is absent from Running.

Now the part everybody gets wrong. These are lists of flags, not single numbers, and each number is a property name. Here are the meanings Microsoft publishes, in full.

AvailableSecurityProperties - what this platform has. RequiredSecurityProperties - what the current policy demands. The values mean the same thing in both, except that value 8 is documented only for Available.

ValueMeaning (Microsoft's wording)What systeminfo calls it
0No relevant properties exist on the device / nothing is required(nothing listed)
1Hypervisor support is available / neededBase Virtualization Support
2Secure Boot is available / neededSecure Boot
3DMA protection is available / neededDMA Protection
4Secure Memory Overwrite is available / neededSecure Memory Overwrite
5NX protections are available / neededUEFI Code Readonly
6SMM mitigations are available / neededSMM Security Mitigations 1.0
7MBEC/GMET is available / neededMode Based Execution Control
8APIC virtualization is available (Available only; Required is documented 0 to 7)APIC Virtualization

SecurityServicesConfigured and SecurityServicesRunning - which tenants are asked for, and which are actually inside VBS right now. Same numbering for both.

ValueService
0No services configured / no services running
1Credential Guard
2Memory integrity (HVCI)
3System Guard Secure Launch
4SMM Firmware Measurement
5Kernel-mode Hardware-enforced Stack Protection
6Kernel-mode Hardware-enforced Stack Protection, in Audit mode
7Hypervisor-Enforced Paging Translation

VirtualizationBasedSecurityStatus - the single most useful number on the whole device. Only three values are documented.

ValueMeaningWhat to do next
0VBS is not enabledNothing is asking for it. Go and look at the policy (link 4).
1VBS is enabled but not runningPolicy was accepted and the launch failed. Check link 5 then link 6. This is the state worth learning.
2VBS is enabled and runningThe foundation is fine. Any remaining problem is in a tenant, not in VBS.

Two more properties on the class share an enumeration: CodeIntegrityPolicyEnforcementStatus and UsermodeCodeIntegrityPolicyEnforcementStatus, where 0 is Off, 1 is Audit and 2 is Enforced. VirtualMachineIsolationProperties uses 1 for AMD SEV-SNP, 2 for Virtualization-based Security and 3 for Intel TDX. Version has exactly one valid value, 1.0.

Gotcha: Win32_Processor lies once the hypervisor is up. The obvious way to check link 2 is Get-CimInstance Win32_Processor and read VMMonitorModeExtensions and SecondLevelAddressTranslationExtensions. On a healthy device with VBS already running, both frequently report False, because the running hypervisor now owns those extensions and the OS can no longer see them directly. Build a detection rule on those two properties and you will flag every working machine in the estate as broken. The reliable signal for link 2 is AvailableSecurityProperties containing 1.

2. msinfo32 and systeminfo

System Information shows the same data in English at the bottom of the System Summary page, which makes it the fastest way to read a device over a screen share. Two of the field names are named explicitly in Microsoft's own instructions: the Credential Guard documentation tells you to confirm Credential Guard appears next to Virtualization-based Security Services Running, and the Secure Launch documentation tells you to look under Virtualization-based Security Services Running and Virtualization-based Security Services Configured. The remaining rows in that block, observed on a live Windows 11 device and matching the text systeminfo prints, are Virtualization-based security (carrying the status), Required Security Properties, Available Security Properties and SMM Isolation Level.

systeminfo prints the identical block as text, which is far easier to collect at scale than a GUI. The command below filters it down.

PowerShell - run elevated
systeminfo | Select-Object -Last 26 # Real output from the lab device, identifiers unchanged because there are none. Virtualization-based security: Status: Running Required Security Properties: Base Virtualization Support Secure Boot DMA Protection Available Security Properties: Base Virtualization Support Secure Boot DMA Protection Secure Memory Overwrite UEFI Code Readonly SMM Security Mitigations 1.0 Mode Based Execution Control Services Running: Credential Guard Hypervisor enforced Code Integrity Secure Launch SMM Firmware Measurement Hyper-V Requirements: A hypervisor has been detected. # HEALTHY: "Status: Running". Every Required line also appears under Available. # BROKEN looks like "Status: Enabled but not running", or a Required line such # as DMA Protection with no matching line in the Available list below it. # The "A hypervisor has been detected" line is normal and is not an error - it # just means systeminfo cannot report Hyper-V readiness from inside a running # hypervisor. On a machine with VBS dead you get a Hyper-V requirements list # instead, and any "No" in it is your link 2 or link 3 answer.

3. The registry

Two trees matter and they are not the same thing. Control\DeviceGuard is the live configuration Windows reads. SOFTWARE\Policies\Microsoft\Windows\DeviceGuard is the managed copy that Group Policy or the DeviceGuard CSP writes. Comparing them tells you whether your policy actually landed.

Shared parent key for the table below: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\DeviceGuard
Value or subkeyType and documented valuesWhat it controls
EnableVirtualizationBasedSecurityREG_DWORD, 1 to enableThe parent switch. Nothing below it works without this.
RequirePlatformSecurityFeaturesREG_DWORD, 1 Secure Boot, 3 Secure Boot and DMAThe platform security level. The single most common cause of enabled-but-not-running.
LockedREG_DWORD, 0 without UEFI lock, 1 with UEFI lockWhether the VBS configuration is persisted into firmware variables.
MandatoryREG_DWORD, 1Refuses to continue booting if the hypervisor or secure kernel fails to load. Handle with extreme care.
Scenarios\HypervisorEnforcedCodeIntegritySubkey. Enabled 1, Locked 0 or 1Memory Integrity. Also carries WasEnabledBy, where deleting the value greys out the Windows Security toggle and 2 restores normal behaviour.
Scenarios\SystemGuardSubkey. Enabled REG_DWORD 1System Guard Secure Launch. Microsoft documents creating this key and value by hand.
Scenarios\CredentialGuard, KernelShadowStacks, KeyGuard, WindowsHelloSubkeys observed on a live Windows 11 deviceObserved and undocumented. These appear under Scenarios on real machines and their value names are not published. Read them for context; do not build detection logic on them, because an undocumented key can change in any update.

Credential Guard is the exception to the tree above: its live value is LsaCfgFlags under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa, with 1 for UEFI lock and 2 for no lock. There is a second LsaCfgFlags in the policy hive under DeviceGuard. Microsoft notes that deleting these values may not disable Credential Guard, and that they must be set to 0.

Registry Editor - HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\DeviceGuard
Name | Type | Data
EnableVirtualizationBasedSecurity | REG_DWORD | 0x00000001 (1)
RequirePlatformSecurityFeatures | REG_DWORD | 0x00000003 (3)
Locked | REG_DWORD | 0x00000001 (1)
Mandatory | (value not present - correct for almost every fleet)
Read this panel as: VBS is asked for (green). The platform security level is 3, so DMA protection is mandatory (amber - fine on this machine, fatal on a machine with no IOMMU). Locked is 1, so this configuration is now persisted in firmware and cannot be removed by deleting the policy (red).

4. The Boot Configuration Data store

Reading the boot entry needs an elevated prompt. This is a read; the /enum verb changes nothing.

Command Prompt - run elevated
bcdedit /enum {current} # Illustrative output. /enum is read-only; nothing here modifies the store. Windows Boot Loader ------------------- identifier {current} device partition=C: path \WINDOWS\system32\winload.efi description Windows 11 hypervisorlaunchtype Auto # HEALTHY: Auto, or no hypervisorlaunchtype line at all - absence means the # default, which is Auto. BROKEN: the word Off. That single word is enough to # hold VBS at "enabled but not running" no matter what policy you deploy. # Also check vsmlaunchtype if it is present; Off there suppresses Virtual # Secure Mode specifically. Non-elevated you get "Access is denied" - treat # that as UNKNOWN, never as healthy.

5. Event Viewer

Microsoft does not publish a complete VBS event ID catalogue. It does publish one small set, and that set is exactly the one that separates a VBS failure from a Credential Guard failure. Open Event Viewer, go to Windows Logs then System, and filter the event source to WinInit.

Channel for the table below: Windows Logs > System, source WinInit (provider Microsoft-Windows-Wininit)
Event IDLevelDocumented meaning
13InformationCredential Guard (LsaIso.exe) was started and will protect LSA credentials.
14InformationCredential Guard configuration. The first variable is 0x1 or 0x2 if it is configured to run and 0x0 if not; the second is 0 for protect mode and 1 for test mode, and should always be 0.
15WarningCredential Guard is configured but the secure kernel is not running; continuing without Credential Guard. This is the VBS smoking gun.
16WarningCredential Guard failed to launch, with an error code.
17Not statedError reading Credential Guard UEFI configuration, with an error code.

Event 15 is worth memorising. It says, in Microsoft's own words, that the tenant was configured and the building was not open. If you see 15, stop investigating Credential Guard and go back to link 5 and link 6.

Event Viewer - Windows Logs > System - filtered to source WinInit
Level | Event ID | Source | Message
Information | 13 | WinInit | Credential Guard was started and will protect LSA credentials.
Information | 14 | WinInit | Credential Guard configuration: Registry Configuration: 0x1 / Test Configuration: 0
Warning | 15 | WinInit | (what you would see instead on a broken device) Credential Guard is configured but the secure kernel is not running; continuing without Credential Guard.
Read this panel as: 13 and 14 together mean the isolated LSA process really launched. If you had 14 with a first variable of 0x1 and then 15 instead of 13, the policy was correct and VBS never came up.

Beyond that documented set, three log channels exist and carry relevant records, but their event IDs and message text are observed and undocumented. Read them for context and do not build fleet detection on them.

ChannelWhat you find there
Microsoft-Windows-DeviceGuard/OperationalRecords of Device Guard policy processing, including a line naming Virtualization Based Security, Secure Boot, DMA Protection, Virtualization Based Code Integrity, Credential Guard, Kernel-mode Hardware-enforced Stack Protection and whether a reboot is required. Extremely useful. Not documented.
Microsoft-Windows-Kernel-Boot/OperationalVSM master key and identity key provisioning records, with status codes. Not documented.
Microsoft-Windows-Hyper-V-Hypervisor-Operational and -AdminHypervisor partition activity. Presence of records here is decent evidence the hypervisor is genuinely running.

Surfaces that genuinely do not apply

Two entries on the usual checklist are honestly not relevant here, and saying so is more useful than inventing something.

There is no text log file for VBS. No .log under %WINDIR% records hypervisor launch. The closest documented thing is Ntbtlog.txt in %WINDIR%, produced when the bootlog boot option is set to yes, which lists loaded and unloaded drivers. That is useful for a driver problem but it will not tell you why the hypervisor did not start. Use the event channels above instead.

There is no service and no scheduled task that drives VBS. The hypervisor and secure kernel are launched by the boot loader before the Service Control Manager exists, so there is nothing to restart and nothing to re-trigger. You will see HvHost (HV Host Service), vmcompute (Hyper-V Host Compute Service) and vmms (Hyper-V Virtual Machine Management) on a machine with the Hyper-V role, but those serve virtual machines, not VBS. Stopping them does not stop VBS, and starting them does not fix it. Nothing under \Microsoft\Windows\ in Task Scheduler drives VBS either. Every VBS change is a reboot.

The fix: platform security level, launch type, policy

Fix the earliest failing link and nothing else, then reboot, then re-measure. Fixing three links at once means you never learn which one mattered.

Group Policy: the full click path and every dropdown option

There is exactly one Group Policy setting for all of this, and it carries six or seven child dropdowns depending on your ADMX version. The parent must be Enabled for any child to do anything.

gpedit.mscComputer ConfigurationAdministrative TemplatesSystemDevice GuardTurn On Virtualization Based Security
  1. Open the Group Policy Management Console, or gpedit.msc for a single machine, and create or edit a GPO.
  2. Navigate to Computer Configuration > Administrative Templates > System > Device Guard.
  3. Double-click Turn On Virtualization Based Security.
  4. Select Enabled. This alone sets EnableVirtualizationBasedSecurity to 1.
  5. Under Select Platform Security Level, choose Secure Boot unless every single machine in scope is known to have an IOMMU.
  6. Under Virtualization Based Protection of Code Integrity, choose Enabled without UEFI lock. Microsoft's guidance is to pick UEFI lock only when you specifically want to stop Memory Integrity being turned off remotely or by a later policy update.
  7. Under Credential Guard Configuration, choose Enabled without lock if you want to keep the ability to turn it off remotely. Leave it Disabled if your scope contains Pro machines.
  8. Leave Require UEFI Memory Attributes Table unticked for a first rollout. Ticking it excludes any device whose firmware does not report a compliant MAT.
  9. Under Secure Launch Configuration, choose Enabled only on hardware you know supports it.
  10. Under Kernel-mode Hardware-enforced Stack Protection, choose Enabled in enforcement mode only after VBS and Memory Integrity are both confirmed running, because it depends on both.
  11. Click OK, then run gpupdate /force from an elevated prompt on a target machine, and reboot.

Here is every documented option, with the value each one writes, so you can map a policy to a device and back.

DropdownDocumented optionsValue written
Select Platform Security LevelSecure Boot / Secure Boot and DMA ProtectionRequirePlatformSecurityFeatures = 1 or 3
Virtualization Based Protection of Code IntegrityDisabled / Enabled with UEFI lock / Enabled without lockHypervisorEnforcedCodeIntegrity = 0, 1, 2
Require UEFI Memory Attributes TableNot required / RequiredRequireUEFIMemoryAttributesTable = 0 or 1
Credential Guard ConfigurationDisabled / Enabled with UEFI lock / Enabled without lockLsaCfgFlags = 0, 1, 2
Secure Launch ConfigurationUnmanaged, configurable by an administrative user / Enables Secure Launch if supported by hardware / Disables Secure LaunchConfigureSystemGuardLaunch = 0, 1, 2
Kernel-mode Hardware-enforced Stack ProtectionEnabled in enforcement mode (needs the 22H2 or later DeviceGuard.admx)Written under the DeviceGuard policy key
Machine Identity Isolation ConfigurationDisabled / Enabled in audit mode / Enabled in enforcement modeMachineIdentityIsolation = 0, 1, 2. Currently Insider Preview only.

Intune: the Settings Catalog path

Intune splits these across two settings-catalog categories, which is the single most confusing thing about configuring VBS from Intune. The VBS parent switch, the platform security level, Credential Guard and Secure Launch sit under Device Guard. Memory Integrity and the MAT requirement sit under Virtualization Based Technology. You will usually need settings from both in one profile.

intune.microsoft.comDevicesConfigurationCreateWindows 10 and laterSettings catalog
  1. Sign in to the Microsoft Intune admin center and go to Devices.
  2. Select Configuration, then Create, then New policy.
  3. Set Platform to Windows 10 and later and Profile type to Settings catalog. Click Create.
  4. Give the profile a name such as CONTOSO-VBS-Baseline and click Next.
  5. Click Add settings. In the picker, search for Device Guard and choose that category.
  6. Tick Turn On Virtualization Based Security and set it to Enable virtualization based security.
  7. Tick Select Platform Security Level and set it to Turns on VBS with Secure Boot. That is the value 1 option.
  8. If your scope is Enterprise or Education only, tick Credential Guard and choose Enabled without lock.
  9. Now search the picker for Virtualization Based Technology and choose that category.
  10. Tick Hypervisor Enforced Code Integrity and set it to Enabled without lock.
  11. Close the picker, click Next through Scope tags, and assign the profile to a small pilot group first.
  12. Click Next, review, and Create. Reboot a pilot device and re-run the checks above.

If you would rather use a custom OMA-URI profile, the documented nodes are below. Data type is int for all of them.

Shared OMA-URI prefix: ./Device/Vendor/MSFT/Policy/Config/
NodeDocumented values
DeviceGuard/EnableVirtualizationBasedSecurity0 disable, 1 enable
DeviceGuard/RequirePlatformSecurityFeatures1 Secure Boot, 3 Secure Boot and DMA
DeviceGuard/LsaCfgFlags0 off, 1 UEFI lock, 2 no lock
DeviceGuard/ConfigureSystemGuardLaunch0 unmanaged, 1 enable if supported, 2 disable
VirtualizationBasedTechnology/HypervisorEnforcedCodeIntegrity0 off, 1 UEFI lock, 2 no lock
VirtualizationBasedTechnology/RequireUEFIMemoryAttributesTable0 not required, 1 required

Tip: neither surface is a superset of the other, and the Defender angle is a third place to look. Everything above exists as both GPO and CSP, so there is no GPO-only or CSP-only trap here. What is easy to miss is that Credential Guard can also be configured from Intune Endpoint security using an Account protection profile, and that Memory Integrity can be turned on from an App Control for Business policy, either through the App Control Wizard's Hypervisor-protected Code Integrity option, the Set-HVCIOptions cmdlet, or the HVCIOptions element in policy XML. Microsoft notes that an App Control policy which turns Memory Integrity on does so even in audit mode. If you are chasing a VBS setting nobody admits to configuring, check for a third-party or older Endpoint Security profile before you blame the hardware.

Fixing the hypervisor launch type

If link 6 is your failure, one command fixes it, and you should suspend BitLocker first because you are changing a boot entry.

  1. From an elevated prompt, suspend BitLocker for one reboot on the OS volume.
  2. Run bcdedit /set hypervisorlaunchtype auto.
  3. If a vsmlaunchtype line was also set to Off, run bcdedit /set vsmlaunchtype auto as well.
  4. Reboot, then re-read Win32_DeviceGuard and confirm VirtualizationBasedSecurityStatus is now 2.

If link 5 is your failure instead, do not touch bcdedit at all. Change the platform security level to Secure Boot only, either in the GPO dropdown or with RequirePlatformSecurityFeatures set to 1, and reboot.

Proof it worked: a real run on a healthy device

The companion script walks all nine links in evaluation order, translates every WMI enumeration to English, and reports the first failing link with its specific remedy. It is read-only. It never writes a registry value, never changes a service, and the only bcdedit call it makes is /enum. It needs no PowerShell modules.

The block below is a genuine run on a Windows 11 Enterprise laptop with VBS healthy. No identifiers appear in the output, so nothing has been replaced.

PowerShell 5.1 - run elevated - genuine run
.\Get-VbsPrerequisiteChain.ps1 -IncludeEvents Session elevated : True PowerShell : 5.1.26100.9168 LINK 2 - processor virtualization extensions and SLAT VirtualizationFirmwareEnabled : True VMMonitorModeExtensions : False SecondLevelAddressTranslationExtensions : False [OK ] Link 2 - Virtualization extensions and SLAT AvailableSecurityProperties contains 1, so hypervisor support is available. # Look at that carefully. Two of the three CPU properties read False on a # machine where VBS is running perfectly, because the live hypervisor owns # those extensions. That is exactly the trap described earlier. LINK 4 - the VBS policy in the registry EnableVirtualizationBasedSecurity : 1 (read ok) RequirePlatformSecurityFeatures : 3 (read ok) Locked : 1 (read ok) Mandatory : (value absent) Scenarios subkeys present under Control\DeviceGuard: - CredentialGuard - HypervisorEnforcedCodeIntegrity - KernelShadowStacks - KeyGuard - SystemGuard - WindowsHello LINK 6 - hypervisor launch type hypervisorlaunchtype : not present in the boot entry # Absent means the default, which is Auto. Healthy. The word "Off" here # would be the whole answer to the ticket. LINK 8 - VirtualizationBasedSecurityStatus VirtualizationBasedSecurityStatus = 2 -> VBS is enabled and running LINK 9 - VBS-hosted services configured versus running SecurityServicesConfigured : 1 Credential Guard, 2 Memory integrity (HVCI), 3 System Guard Secure Launch, 4 SMM Firmware Measurement SecurityServicesRunning : 1 Credential Guard, 2 Memory integrity (HVCI), 3 System Guard Secure Launch, 4 SMM Firmware Measurement VERDICT Link 1 OK 64-bit Windows Link 6 OK hypervisorlaunchtype Link 2 OK Virtualization ext and SLAT Link 7 OK Hypervisor binaries Link 3 OK UEFI and Secure Boot Link 8 OK VBS running Link 4 OK VBS policy present Link 9 OK Configured == Running Link 5 OK Platform level satisfiable ALL LINKS HEALTHY. # HEALTHY looks like this: every link OK and exit code 0. BROKEN prints # "FIRST FAILING LINK" with the remedy, and exits 1. If any read failed the # script refuses to report a clean result at all, because a clean result you # did not actually measure is worse than no result.

The Wininit evidence from the same run confirms the tenant really launched, not just that policy was accepted. Both lines are real output from the lab device.

Id 13 (Information) Credential Guard was started and will protect LSA credentials.
Id 14 (Information) Credential Guard configuration: Registry Configuration: 0x1 Test Configuration: 0

Event 14 reporting a first variable of 0x1 means configured to run with UEFI lock, and event 13 immediately after it means it actually did run. Event 15 in place of 13 would have meant the exact opposite: policy fine, VBS absent.

Finally, the observed Microsoft-Windows-DeviceGuard/Operational record from the same device, which is the single most readable summary of a policy evaluation anywhere on the machine. Remember that this channel is undocumented.

Device Guard successfully processed the Group Policy: Virtualization Based Security = Enabled, Secure Boot = On, DMA Protection = On, Virtualization Based Code Integrity = Disabled, Credential Guard = Enabled, Machine Identity Isolation = Disabled, Kernel-mode Hardware-enforced Stack Protection = Not configured, Reboot required = No, Status = 0x0.

One line, every dropdown, and a status code. If you ever get to build detection at scale, do it on Win32_DeviceGuard rather than on this, precisely because this text can change without notice.

References

Microsoft official documentation:

Community deep-dives, each fetched and confirmed on topic before citing:

AuthorArticleWhy it is worth reading
Rudy OomsA walk among the Credential GuardsWalks the Intune side end to end - Endpoint Security, Settings Catalog and PowerShell - and shows the same Control\DeviceGuard values including RequirePlatformSecurityFeatures. Also flags the Enterprise or Education requirement for the CSP path.
MSEndpointMgrEnable Credential Guard during OSD with ConfigMgrA 2016 ConfigMgr-era piece, so treat the surrounding tooling as historical, but it sets the same two DeviceGuard values and is a useful reminder that this registry surface has been stable for a decade.

The companion script is at Get-VbsPrerequisiteChain.ps1 in the Windows-11-Scripts repository, under the folder named after this post's slug.

PowerShell — companion script

Download it from Imran76Awan/Windows-11-Scripts — no sign-in required. It is read-only: it reports and never changes a device or anything in Intune. Validate it in your own environment before relying on the output.

Get-VbsPrerequisiteChain.ps1 — Walks the Virtualization-based Security (VBS) prerequisite chain in the order Windows
View all scripts on GitHub
Was this post helpful?
React below — no account needed
Share this post
LinkedIn X / Twitter Reddit Bluesky

More from EndpointWeekly

Windows 11
Memory Integrity will not turn on: finding the incompatible…
Memory Integrity (HVCI) is the highest-value hardening toggle in Windows 11, and it…
Windows 11
LSA Protection, RunAsPPL and Credential Guard: Three Defences…
LSASS is the highest-value target on a Windows device, and Windows offers three…
Windows 11
Windows Search finds nothing, or eats the disk: the index, its…
The Windows Search index is a real database on disk, and most search failures are a…