test_varstored_sb.py

import pytest

import logging

from lib.commands import SSHCommandFailed
from lib.efi import EFI_AT_ATTRS, EFI_VARIABLE_APPEND_WRITE, SB_CERTS, EFIAuth, image_security_database_guid
from lib.snapshot import Snapshot
from lib.vm import VM

from .utils import (
    _test_key_exchanges,
    boot_and_check_no_sb_errors,
    boot_and_check_sb_failed,
    boot_and_check_sb_succeeded,
    generate_keys,
    revert_vm_state,
    sign_efi_bins,
)

from typing import Generator

# These tests check the behaviour of XAPI and varstored as they are in XCP-ng 8.3
# For XCP-ng 8.2, see test_uefistored_sb.py

# Requirements:
# On the test runner:
# - See requirements documented in the project's README.md for Guest UEFI Secure Boot tests
# From --hosts parameter:
# - host: XCP-ng host >= 8.3
# From --vm parameter
# - A UEFI VM to import
#   Some tests are Linux-only and some tests are Windows-only.
#   The Windows tests here (e.g. test_key_upgrade_bitlocker) require Windows Server.

pytestmark = pytest.mark.default_vm('mini-linux-x86_64-uefi')


@pytest.mark.small_vm
@pytest.mark.usefixtures("host_at_least_8_3")
@pytest.mark.usefixtures("skip_if_not_unix_vm")
class TestGuestLinuxUEFISecureBoot:
    PK: EFIAuth
    KEK: EFIAuth
    db: EFIAuth
    dbx: EFIAuth

    @pytest.fixture(autouse=True)
    def setup_and_cleanup(self, uefi_vm_and_snapshot: tuple[VM, Snapshot]) -> Generator[None, None, None]:
        vm, snapshot = uefi_vm_and_snapshot
        self.PK, self.KEK, self.db, self.dbx = generate_keys()
        yield
        revert_vm_state(vm, snapshot)

    @pytest.mark.multi_vms  # test that SB works on various UEFI unix/linux VMs, not just on `small_vm`
    def test_boot_success_when_vm_db_set_and_images_signed(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.install_uefi_certs([self.PK, self.KEK, self.db])
        sign_efi_bins(vm, self.db)
        vm.param_set('platform', True, key='secureboot')
        boot_and_check_sb_succeeded(vm)

    def test_boot_fails_when_vm_db_set_and_images_unsigned(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.install_uefi_certs([self.PK, self.KEK, self.db])
        vm.param_set('platform', True, key='secureboot')
        boot_and_check_sb_failed(vm)

    def test_boot_succeeds_when_vm_certs_set_and_sb_disabled(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.install_uefi_certs([self.PK, self.KEK, self.db])
        vm.param_set('platform', False, key='secureboot')
        boot_and_check_no_sb_errors(vm)

    def test_boot_fails_when_vm_dbx_revokes_signed_images(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.install_uefi_certs([self.PK, self.KEK, self.db, self.dbx])
        sign_efi_bins(vm, self.db)
        vm.param_set('platform', True, key='secureboot')
        boot_and_check_sb_failed(vm)

    def test_boot_success_when_initial_vm_keys_not_signed_by_parent(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        PK, KEK, db, _ = generate_keys(self_signed=True)
        vm.install_uefi_certs([PK, KEK, db])
        sign_efi_bins(vm, db)
        vm.param_set('platform', True, key='secureboot')
        boot_and_check_sb_succeeded(vm)

    def test_sb_off_really_means_off(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.install_uefi_certs([self.PK, self.KEK, self.db])
        sign_efi_bins(vm, self.db)
        vm.param_set('platform', False, key='secureboot')
        vm.start()
        vm.wait_for_vm_running_and_ssh_up()
        logging.info("Check that SB is NOT enabled according to the OS.")
        assert not vm.booted_with_secureboot()

    def test_append_with_default(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.host.pool.clear_custom_uefi_certs()
        vm.set_uefi_user_mode()
        vm.set_variable_from_file(
            SB_CERTS.dbx_hashes_ms_amd64(),
            image_security_database_guid,
            "dbx",
            EFI_AT_ATTRS | EFI_VARIABLE_APPEND_WRITE,
        )
        vm.start()
        vm.wait_for_vm_running_and_ssh_up()

    def test_append_with_poison(self, uefi_vm: VM) -> None:
        """
        Context: https://xcp-ng.org/blog/2025/10/30/xcp-ng-8-3-varstored-update-unbootable-vm-risk-and-remediation/

        In short, the dbx variable previously used in the bad update did not use the Microsoft owner GUID, preventing
        deduplication of EFI signature data entries during an append call. Normally, this would not cause the VM to
        crash; except varstored does not check for the variable data length on append, triggering the issue.
        """
        vm = uefi_vm
        vm.host.pool.clear_custom_uefi_certs()
        vm.set_uefi_user_mode()
        vm.set_variable_from_file(SB_CERTS.dbx_poison(), image_security_database_guid, "dbx", EFI_AT_ATTRS)
        try:
            vm.set_variable_from_file(
                SB_CERTS.dbx_hashes_ms_amd64(),
                image_security_database_guid,
                "dbx",
                EFI_AT_ATTRS | EFI_VARIABLE_APPEND_WRITE,
            )
        except SSHCommandFailed:
            # Appending the MS dbx may succeed or fail, doesn't matter, as appending the poison may not necessarily take
            # dbx over the DATA_LIMIT. The important thing is that the VM boots up following this append attempt.
            pass
        vm.start()
        vm.wait_for_vm_running_and_ssh_up()


@pytest.mark.usefixtures("host_at_least_8_3")
@pytest.mark.usefixtures("skip_if_not_windows_vm")
class TestGuestWindowsUEFISecureBoot:
    @pytest.fixture(autouse=True)
    def setup_and_cleanup(self, uefi_vm_and_snapshot: tuple[VM, Snapshot]) -> Generator[None, None, None]:
        vm, snapshot = uefi_vm_and_snapshot
        yield
        revert_vm_state(vm, snapshot)

    @pytest.mark.small_vm  # test on the smallest Windows VM, if that means anything with Windows
    def test_windows_fails(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        PK, KEK, db, _ = generate_keys(self_signed=True)
        vm.install_uefi_certs([PK, KEK, db])
        vm.param_set('platform', True, key='secureboot')
        boot_and_check_sb_failed(vm)

    @pytest.mark.multi_vms  # test that SB works on every Windows VM we have
    def test_windows_succeeds(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.param_set('platform', True, key='secureboot')
        # Install certs in the VM. They must be official MS certs.
        # We install them first in the pool with `secureboot-certs install`, which requires internet access
        logging.info("Install MS certs on pool with secureboot-certs install")
        vm.host.ssh('secureboot-certs install')
        # Now install the default pool certs in the VM
        vm.set_uefi_user_mode()
        boot_and_check_sb_succeeded(vm)


@pytest.mark.small_vm
@pytest.mark.usefixtures("host_at_least_8_3")
class TestCertsMissingAndSbOn:
    @pytest.fixture(autouse=True)
    def setup_and_cleanup(self, uefi_vm_and_snapshot: tuple[VM, Snapshot]) -> Generator[None, None, None]:
        vm, snapshot = uefi_vm_and_snapshot
        vm.param_set('platform', True, key='secureboot')
        yield
        revert_vm_state(vm, snapshot)

    def test_setup_mode_and_sb_on(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.set_uefi_setup_mode()
        boot_and_check_no_sb_errors(vm)

    def test_only_pk_present_but_sb_on(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        PK, _, _, _ = generate_keys()
        vm.install_uefi_certs([PK])
        boot_and_check_sb_failed(vm)

    def test_only_pk_and_kek_present_but_sb_on(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        PK, KEK, _, _ = generate_keys()
        vm.install_uefi_certs([PK, KEK])
        boot_and_check_sb_failed(vm)

    def test_only_pk_and_db_present_but_sb_on(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        PK, _, db, _ = generate_keys()
        vm.install_uefi_certs([PK, db])
        boot_and_check_sb_failed(vm)


@pytest.mark.small_vm
@pytest.mark.usefixtures("host_at_least_8_3")
@pytest.mark.usefixtures("unix_vm")
class TestUEFIKeyExchange:
    @pytest.fixture(autouse=True)
    def setup_and_cleanup(self, uefi_vm_and_snapshot: tuple[VM, Snapshot]) -> Generator[None, None, None]:
        vm, snapshot = uefi_vm_and_snapshot
        yield
        revert_vm_state(vm, snapshot)

    def test_key_exchanges(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.set_uefi_setup_mode()

        _test_key_exchanges(vm)


@pytest.mark.small_vm
@pytest.mark.usefixtures("host_at_least_8_3")
@pytest.mark.usefixtures("windows_vm")
class TestGuestWindowsUEFIKeyUpgrade:
    @pytest.fixture(autouse=True)
    def setup_and_cleanup(self, uefi_vm_and_snapshot: tuple[VM, Snapshot]) -> Generator[None, None, None]:
        vm, snapshot = uefi_vm_and_snapshot
        if not vm.get_vtpm_uuid():
            vm.create_vtpm()
        yield
        revert_vm_state(vm, snapshot)

    def install_old_certs(self, vm: VM) -> list[EFIAuth]:
        """Populate a key set that looks like the old defaults."""
        PK = EFIAuth.self_signed("PK")
        KEK = EFIAuth.self_signed("KEK", other_certs=[SB_CERTS.kek_ms_2011()])
        db = EFIAuth("db", other_certs=[SB_CERTS.db_uefi_2011(), SB_CERTS.db_win_2011()])
        # Some test VMs don't like an empty dbx when their own dbx is empty, so just put whatever in there
        dbx = EFIAuth.self_signed("dbx")

        PK.sign_auth(PK)
        PK.sign_auth(KEK)
        KEK.sign_auth(db)
        KEK.sign_auth(dbx)

        vm.install_uefi_certs([PK, KEK, db, dbx])
        return [PK, KEK, db, dbx]

    def install_new_certs(self, vm: VM, signer: EFIAuth) -> None:
        """Populate a key set that looks like the new defaults with 2023 MS keys."""
        newPK = EFIAuth.self_signed("PK")
        newKEK = EFIAuth("KEK", other_certs=[SB_CERTS.kek_ms_2011(), SB_CERTS.kek_ms_2023()])
        newdb = EFIAuth(
            "db",
            other_certs=[
                SB_CERTS.db_win_2011(),
                SB_CERTS.db_win_2023(),
                SB_CERTS.db_uefi_2011(),
                SB_CERTS.db_uefi_2023(),
                SB_CERTS.db_oprom_2023(),
            ],
        )
        newdbx = EFIAuth("dbx")

        newPK.sign_auth(newPK)
        # Technically, there's no need to sign the other databases since we're setting them from Dom0.
        # If signing with the old PK works, there'd be no need to test signing with the new PK.
        # We use an invalid signer to test scenarios where the user mixes and matches default and custom keys.
        signer.sign_auth(newKEK)
        signer.sign_auth(newdb)
        signer.sign_auth(newdbx)

        vm.install_uefi_certs([newPK, newKEK, newdb, newdbx])

    def test_key_upgrade(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.param_set("platform", True, key="secureboot")

        PK, _, _, _ = self.install_old_certs(vm)
        boot_and_check_sb_succeeded(vm)

        vm.shutdown(verify=True)

        self.install_new_certs(vm, PK)
        boot_and_check_sb_succeeded(vm)

    def test_key_upgrade_bitlocker(self, uefi_vm: VM) -> None:
        vm = uefi_vm
        vm.param_set("platform", True, key="secureboot")

        PK, _, _, _ = self.install_old_certs(vm)
        boot_and_check_sb_succeeded(vm)

        vm.execute_powershell_script("Add-WindowsFeature BitLocker,EnhancedStorage")
        vm.reboot(verify=True)

        vm.execute_powershell_script("Enable-BitLocker $Env:SystemDrive -TpmProtector -UsedSpaceOnly")
        # Confirm if PCR7 is bound.
        assert (
            vm.execute_powershell_script(
                r"""Get-CimInstance -Namespace Root\CIMV2\Security\MicrosoftVolumeEncryption `
-Query "select * from Win32_EncryptableVolume where VolumeType=0" |
Invoke-CimMethod -MethodName GetSecureBootBindingState |
Where-Object ReturnValue -eq 0 |
Select-Object -ExpandProperty BindingState"""
            )
            == "3"
        )  # Bound
        vm.execute_powershell_script("Suspend-BitLocker $Env:SystemDrive")
        vm.shutdown(verify=True)

        self.install_new_certs(vm, PK)
        boot_and_check_sb_succeeded(vm)

        # After Enable-BitLocker, Windows would boot into encryption test.
        # If the test failed, Windows would cancel the encryption and give the status FullyDecrypted.
        assert vm.execute_powershell_script("(Get-BitLockerVolume $Env:SystemDrive).VolumeStatus") != "FullyDecrypted"