Allow guest access to EFI confidential computing secret area
Subsystems (4)
v8 cover Allow guest access to EFI confidential computing secret area
Confidential computing (coco) hardware such as AMD SEV (Secure Encrypted Virtualization) allows guest owners to inject secrets into the VMs memory without the host/hypervisor being able to read them. In SEV, secret injection is performed early in the VM launch process, before the guest starts running.
OVMF already reserves designated area for secret injection (in its AmdSev package; see edk2 commit 01726b6d23d4 "OvmfPkg/AmdSev: Expose the Sev Secret area using a configuration table" [1]), but the secrets were not available in the guest kernel.
The patch series keeps the address of the EFI-provided memory for injected secrets, and exposes the secrets to userspace via securityfs using a new efi_secret kernel module. The module is autoloaded (by the EFI driver) if the secret area is populated.
The first patch in EFI keeps the address of the secret area as passed in the EFI configuration table. The second patch introduces the new efi_secret module that exposes the content of the secret entries as securityfs files, and allows clearing out secrets with a file unlink interface. The third patch auto-loads the efi_secret module during startup if the injected secrets area is populated. The last patch documents the data flow of confidential computing secret injection.
As a usage example, consider a guest performing computations on encrypted files. The Guest Owner provides the decryption key (= secret) using the secret injection mechanism. The guest application reads the secret from the efi_secret filesystem and proceeds to decrypt the files into memory and then performs the needed computations on the content.
In this example, the host can't read the files from the disk image because they are encrypted. Host can't read the decryption key because it is passed using the secret injection mechanism (= secure channel). Host can't read the decrypted content from memory because it's a confidential (memory-encrypted) guest.
This has been tested with AMD SEV and SEV-ES guests, but the kernel side of handling the secret area has no SEV-specific dependencies, and therefore might be usable (perhaps with minor changes) for any confidential computing hardware that can publish the secret area via the standard EFI config table entry.
To enable this functionality, set CONFIG_EFI_SECRET=m when building the guest kernel.
Here is a simple example for usage of the efi_secret module in a guest to which an EFI secret area with 4 secrets was injected during launch:
# ls -la /sys/kernel/security/secrets/coco total 0 drwxr-xr-x 2 root root 0 Jun 28 11:54 . drwxr-xr-x 3 root root 0 Jun 28 11:54 .. -r--r----- 1 root root 0 Jun 28 11:54 736870e5-84f0-4973-92ec-06879ce3da0b -r--r----- 1 root root 0 Jun 28 11:54 83c83f7f-1356-4975-8b7e-d3a0b54312c6 -r--r----- 1 root root 0 Jun 28 11:54 9553f55d-3da2-43ee-ab5d-ff17f78864d2 -r--r----- 1 root root 0 Jun 28 11:54 e6f5a162-d67f-4750-a67c-5d065f2a9910
# hd /sys/kernel/security/secrets/coco/e6f5a162-d67f-4750-a67c-5d065f2a9910 00000000 74 68 65 73 65 2d 61 72 65 2d 74 68 65 2d 6b 61 |these-are-the-ka| 00000010 74 61 2d 73 65 63 72 65 74 73 00 01 02 03 04 05 |ta-secrets......| 00000020 06 07 |..| 00000022
# rm /sys/kernel/security/secrets/coco/e6f5a162-d67f-4750-a67c-5d065f2a9910
# ls -la /sys/kernel/security/secrets/coco total 0 drwxr-xr-x 2 root root 0 Jun 28 11:55 . drwxr-xr-x 3 root root 0 Jun 28 11:54 .. -r--r----- 1 root root 0 Jun 28 11:54 736870e5-84f0-4973-92ec-06879ce3da0b -r--r----- 1 root root 0 Jun 28 11:54 83c83f7f-1356-4975-8b7e-d3a0b54312c6 -r--r----- 1 root root 0 Jun 28 11:54 9553f55d-3da2-43ee-ab5d-ff17f78864d2
[1] https://github.com/tianocore/edk2/commit/01726b6d23d4
---
v8 changes:
- Change path of filesystem to <securityfs>/secrets/coco and fix the documentation accordingly (Thanks Gerd, Matthew)
- Remove patch 2/5 (of v7) because the latest OVMF release (edk2-stable202202) already contains the fix to mark the launch secret page as EFI_RESERVED_TYPE.
v7: https://lore.kernel.org/linux-coco/[email protected]/
v7 changes:
- Improve description of efi_secret module in Kconfig.
- Fix sparse warnings on pointer address space mismatch
(Reported-by: kernel test robot <[email protected]>)
v6: https://lore.kernel.org/linux-coco/[email protected]/
v6 changes:
- Autoload the efi_secret module if the secret area is populated
(thanks Greg KH).
- efi_secret: Depend on X86_64 because we use ioremap_encrypted() which is only defined for this arch.
- efi_secret.c: Remove unneeded tableheader_guid local variable.
- Documentation fixes.
v5: https://lore.kernel.org/linux-coco/[email protected]/
v5 changes:
- Simplify EFI code: instead of copying the secret area, the firmware marks the secret area as EFI_RESERVED_TYPE, and then the uefi_init() code just keeps the pointer as it appears in the EFI configuration table. The use of reserved pages is similar to the AMD SEV-SNP patches for handling SNP-Secrets and SNP-CPUID pages.
- In order to handle OVMF releases out there which mark the confidential computing secrets page as EFI_BOOT_SERVICES_DATA, add efi/libstub code that detects this and fixes the E820 map to reserve this page.
- In the efi_secret module code, map the secrets page using ioremap_encrypted (again, similar to the AMD SEV-SNP guest patches for accessing SNP-Secrets and SNP-CPUID pages).
- Add documentation in Documentation/security/coco/efi_secret.
v4: https://lore.kernel.org/linux-coco/[email protected]/
v4 changes:
- Guard all the new EFI and efi-stub code (patches 1+2) with #ifdef CONFIG_EFI_COCO_SECRET (thanks Greg KH). Selecting CONFIG_EFI_SECRET=m (patch 3) will enable the EFI parts as well.
- Guard call to clflush_cache_range() with #ifdef CONFIG_X86 (Reported-by: kernel test robot <[email protected]>)
v3: https://lore.kernel.org/linux-coco/[email protected]/
v3 changes:
- Rename the module to efi_secret
- Remove the exporting of clean_cache_range
- Use clflush_cache_range in wipe_memory
- Document function wipe_memory
- Initialize efi.coco_secret to EFI_INVALID_TABLE_ADDR to correctly detect when there's no secret area published in the EFI configuration tables
v2: https://lore.kernel.org/linux-coco/[email protected]
v2 changes:
- Export clean_cache_range()
- When deleteing a secret, call clean_cache_range() after explicit_memzero
- Add Documentation/ABI/testing/securityfs-coco-sev_secret
v1: https://lore.kernel.org/linux-coco/[email protected]/
RFC: https://lore.kernel.org/linux-coco/[email protected]/
Dov Murik (4):
efi: Save location of EFI confidential computing area
virt: Add efi_secret module to expose confidential computing secrets
efi: Load efi_secret module if EFI secret area is populated
docs: security: Add secrets/coco documentation
Documentation/ABI/testing/securityfs-secrets-coco | 51 +++ Documentation/security/index.rst | 1 + Documentation/security/secrets/coco.rst | 103 ++++++ Documentation/security/secrets/index.rst | 9 + arch/x86/platform/efi/efi.c | 3 + drivers/firmware/efi/Kconfig | 16 + drivers/firmware/efi/Makefile | 1 + drivers/firmware/efi/coco.c | 58 ++++ drivers/firmware/efi/efi.c | 6 + drivers/virt/Kconfig | 3 + drivers/virt/Makefile | 1 + drivers/virt/coco/efi_secret/Kconfig | 19 ++ drivers/virt/coco/efi_secret/Makefile | 2 + drivers/virt/coco/efi_secret/efi_secret.c | 337 ++++++++++++++++++++ include/linux/efi.h | 10 + 15 files changed, 620 insertions(+) create mode 100644 Documentation/ABI/testing/securityfs-secrets-coco create mode 100644 Documentation/security/secrets/coco.rst create mode 100644 Documentation/security/secrets/index.rst create mode 100644 drivers/firmware/efi/coco.c create mode 100644 drivers/virt/coco/efi_secret/Kconfig create mode 100644 drivers/virt/coco/efi_secret/Makefile create mode 100644 drivers/virt/coco/efi_secret/efi_secret.c
base-commit: 7e57714cd0ad2d5bb90e50b5096a0e671dec1ef3
Signature · 1 line
2.25.1
PATCH v8 1/4 efi: Save location of EFI confidential computing area
Confidential computing (coco) hardware such as AMD SEV (Secure Encrypted Virtualization) allows a guest owner to inject secrets into the VMs memory without the host/hypervisor being able to read them.
Firmware support for secret injection is available in OVMF, which reserves a memory area for secret injection and includes a pointer to it the in EFI config table entry LINUX_EFI_COCO_SECRET_TABLE_GUID.
If EFI exposes such a table entry, uefi_init() will keep a pointer to the EFI config table entry in efi.coco_secret, so it can be used later by the kernel (specifically drivers/virt/coco/efi_secret). It will also appear in the kernel log as "CocoSecret=ADDRESS"; for example:
[ 0.000000] efi: EFI v2.70 by EDK II
[ 0.000000] efi: CocoSecret=0x7f22e680 SMBIOS=0x7f541000 ACPI=0x7f77e000 ACPI 2.0=0x7f77e014 MEMATTR=0x7ea0c018The new functionality can be enabled with CONFIG_EFI_COCO_SECRET=y.
--- arch/x86/platform/efi/efi.c | 3 +++ drivers/firmware/efi/Kconfig | 16 ++++++++++++++++ drivers/firmware/efi/efi.c | 6 ++++++ include/linux/efi.h | 10 ++++++++++ 4 files changed, 35 insertions(+)
arch/x86/platform/efi/efi.c +3 -0
@@ -93,6 +93,9 @@ static const unsigned long * const efi_tables[] = {#ifdef CONFIG_LOAD_UEFI_KEYS &efi.mokvar_table,#endif +#ifdef CONFIG_EFI_COCO_SECRET + &efi.coco_secret, +#endif };u64 efi_setup;/* efi setup_data physical address */
drivers/firmware/efi/Kconfig +16 -0
@@ -284,3 +284,19 @@ config EFI_CUSTOM_SSDT_OVERLAYS See Documentation/admin-guide/acpi/ssdt-overlays.rst for more information. + +config EFI_COCO_SECRET + bool "EFI Confidential Computing Secret Area Support" + depends on EFI + help + Confidential Computing platforms (such as AMD SEV) allow the + Guest Owner to securely inject secrets during guest VM launch. + The secrets are placed in a designated EFI reserved memory area. + + In order to use the secrets in the kernel, the location of the secret + area (as published in the EFI config table) must be kept. + + If you say Y here, the address of the EFI secret area will be kept + for usage inside the kernel. This will allow the + virt/coco/efi_secret module to access the secrets, which in turn + allows userspace programs to access the injected secrets.
drivers/firmware/efi/efi.c +6 -0
@@ -46,6 +46,9 @@ struct efi __read_mostly efi = {#ifdef CONFIG_LOAD_UEFI_KEYS .mokvar_table = EFI_INVALID_TABLE_ADDR,#endif +#ifdef CONFIG_EFI_COCO_SECRET + .coco_secret = EFI_INVALID_TABLE_ADDR, +#endif };EXPORT_SYMBOL (efi);
@@ -528,6 +531,9 @@ static const efi_config_table_type_t common_tables[] __initconst = {#endif #ifdef CONFIG_LOAD_UEFI_KEYS {LINUX_EFI_MOK_VARIABLE_TABLE_GUID, &efi.mokvar_table, "MOKvar" }, +#endif +#ifdef CONFIG_EFI_COCO_SECRET + {LINUX_EFI_COCO_SECRET_AREA_GUID, &efi.coco_secret, "CocoSecret" }, #endif {}, };
include/linux/efi.h +10 -0
@@ -405,6 +405,7 @@ void efi_native_runtime_setup(void);#define LINUX_EFI_MEMRESERVE_TABLE_GUID EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5, 0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)#define LINUX_EFI_INITRD_MEDIA_GUID EFI_GUID(0x5568e427, 0x68fc, 0x4f3d, 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68)#define LINUX_EFI_MOK_VARIABLE_TABLE_GUID EFI_GUID(0xc451ed2b, 0x9694, 0x45d3, 0xba, 0xba, 0xed, 0x9f, 0x89, 0x88, 0xa3, 0x89) +#define LINUX_EFI_COCO_SECRET_AREA_GUID EFI_GUID(0xadf956ad, 0xe98c, 0x484c, 0xae, 0x11, 0xb5, 0x1c, 0x7d, 0x33, 0x64, 0x47)/* OEM GUIDs */ #define DELLEMC_EFI_RCI2_TABLE_GUID EFI_GUID(0x2d9f28a2, 0xa886, 0x456a, 0x97, 0xa8, 0xf1, 0x1e, 0xf2, 0x4f, 0xf4, 0x55)
@@ -596,6 +597,7 @@ extern struct efi {unsigned long tpm_log;/* TPM2 Event Log table */ unsigned long tpm_final_log;/* TPM2 Final Events Log table */ unsigned long mokvar_table;/* MOK variable config table */ +unsigned long coco_secret;/* Confidential computing secret table */ efi_get_time_t *get_time;efi_set_time_t *set_time;
@@ -1335,4 +1337,12 @@ extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);static inline void efifb_setup_from_dmi (struct screen_info *si,const char *opt) { }#endif +struct linux_efi_coco_secret_area { +u64 base_pa; +u64 size; +}; + +/* Header of a populated EFI secret area */ +#define EFI_SECRET_TABLE_HEADER_GUID EFI_GUID(0x1e74f542, 0x71dd, 0x4d66, 0x96, 0x3e, 0xef, 0x42, 0x87, 0xff, 0x17, 0x3b) +#endif /* _LINUX_EFI_H */
Signature · 1 line
2.25.1
PATCH v8 2/4 virt: Add efi_secret module to expose confidential computing secrets
In reply to Dov MurikThe new efi_secret module exposes the confidential computing (coco) EFI secret area via securityfs interface.
When the module is loaded (and securityfs is mounted, typically under /sys/kernel/security), a "secrets/coco" directory is created in securityfs. In it, a file is created for each secret entry. The name of each such file is the GUID of the secret entry, and its content is the secret data.
This allows applications running in a confidential computing setting to read secrets provided by the guest owner via a secure secret injection mechanism (such as AMD SEV's LAUNCH_SECRET command).
Removing (unlinking) files in the "secrets/coco" directory will zero out the secret in memory, and remove the filesystem entry. If the module is removed and loaded again, that secret will not appear in the filesystem.
--- Documentation/ABI/testing/securityfs-secrets-coco | 51 +++ drivers/virt/Kconfig | 3 + drivers/virt/Makefile | 1 + drivers/virt/coco/efi_secret/Kconfig | 16 + drivers/virt/coco/efi_secret/Makefile | 2 + drivers/virt/coco/efi_secret/efi_secret.c | 337 ++++++++++++++++++++ 6 files changed, 410 insertions(+)
Documentation/ABI/testing/securityfs-secrets-coco new file +51 -0
@@ -0,0 +1,51 @@ +What: security/secrets/coco +Date: February 2022 +Contact: Dov Murik <[email protected]> +Description: + Exposes confidential computing (coco) EFI secrets to + userspace via securityfs. + + EFI can declare memory area used by confidential computing + platforms (such as AMD SEV and SEV-ES) for secret injection by + the Guest Owner during VM's launch. The secrets are encrypted + by the Guest Owner and decrypted inside the trusted enclave, + and therefore are not readable by the untrusted host. + + The efi_secret module exposes the secrets to userspace. Each + secret appears as a file under <securityfs>/secrets/coco, + where the filename is the GUID of the entry in the secrets + table. This module is loaded automatically by the EFI driver + if the EFI secret area is populated. + + Two operations are supported for the files: read and unlink. + Reading the file returns the content of secret entry. + Unlinking the file overwrites the secret data with zeroes and + removes the entry from the filesystem. A secret cannot be read + after it has been unlinked. + + For example, listing the available secrets:: + + # modprobe efi_secret + # ls -l /sys/kernel/security/secrets/coco + -r--r----- 1 root root 0 Jun 28 11:54 736870e5-84f0-4973-92ec-06879ce3da0b + -r--r----- 1 root root 0 Jun 28 11:54 83c83f7f-1356-4975-8b7e-d3a0b54312c6 + -r--r----- 1 root root 0 Jun 28 11:54 9553f55d-3da2-43ee-ab5d-ff17f78864d2 + -r--r----- 1 root root 0 Jun 28 11:54 e6f5a162-d67f-4750-a67c-5d065f2a9910 + + Reading the secret data by reading a file:: + + # cat /sys/kernel/security/secrets/coco/e6f5a162-d67f-4750-a67c-5d065f2a9910 + the-content-of-the-secret-data + + Wiping a secret by unlinking a file:: + + # rm /sys/kernel/security/secrets/coco/e6f5a162-d67f-4750-a67c-5d065f2a9910 + # ls -l /sys/kernel/security/secrets/coco + -r--r----- 1 root root 0 Jun 28 11:54 736870e5-84f0-4973-92ec-06879ce3da0b + -r--r----- 1 root root 0 Jun 28 11:54 83c83f7f-1356-4975-8b7e-d3a0b54312c6 + -r--r----- 1 root root 0 Jun 28 11:54 9553f55d-3da2-43ee-ab5d-ff17f78864d2 + + Note: The binary format of the secrets table injected by the + Guest Owner is described in + drivers/virt/coco/efi_secret/efi_secret.c under "Structure of + the EFI secret area".
drivers/virt/Kconfig +3 -0
@@ -36,4 +36,7 @@ source "drivers/virt/vboxguest/Kconfig" source "drivers/virt/nitro_enclaves/Kconfig" source "drivers/virt/acrn/Kconfig" + +source "drivers/virt/coco/efi_secret/Kconfig" + endif
drivers/virt/Makefile +1 -0
@@ -8,3 +8,4 @@ obj-y += vboxguest/ obj-$(CONFIG_NITRO_ENCLAVES) += nitro_enclaves/ obj-$(CONFIG_ACRN_HSM) += acrn/ +obj-$(CONFIG_EFI_SECRET) += coco/efi_secret/
drivers/virt/coco/efi_secret/Kconfig new file +16 -0
@@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0-only +config EFI_SECRET + tristate "EFI secret area securityfs support" + depends on EFI && X86_64 + select EFI_COCO_SECRET + select SECURITYFS + help + This is a driver for accessing the EFI secret area via securityfs. + The EFI secret area is a memory area designated by the firmware for + confidential computing secret injection (for example for AMD SEV + guests). The driver exposes the secrets as files in + <securityfs>/secrets/coco. Files can be read and deleted (deleting + a file wipes the secret from memory). + + To compile this driver as a module, choose M here. + The module will be called efi_secret.
drivers/virt/coco/efi_secret/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +obj-$(CONFIG_EFI_SECRET) += efi_secret.o
drivers/virt/coco/efi_secret/efi_secret.c new file +337 -0
337 lines not on this page · raw message
Signature · 1 line
2.25.1
Re: [PATCH v8 2/4] virt: Add efi_secret module to expose confidential computing secrets
Quoted 13 lines · Dov Murik
The new
efi_secretmodule exposes the confidential computing (coco) EFI secret area via securityfs interface.When the module is loaded (and securityfs is mounted, typically under
/sys/kernel/security), a "secrets/coco" directory is created in securityfs. In it, a file is created for each secret entry. The name of each such file is the GUID of the secret entry, and its content is the secret data.This allows applications running in a confidential computing setting to read secrets provided by the guest owner via a secure secret injection mechanism (such as AMD SEV's
LAUNCH_SECRETcommand).
Quoted 5 lines
Removing (unlinking) files in the "secrets/coco" directory will zero out the secret in memory, and remove the filesystem entry. If the module is removed and loaded again, that secret will not appear in the filesystem.
Signed-off-by Dov Murik <[email protected]>
PATCH v8 3/4 efi: Load efi_secret module if EFI secret area is populated
In reply to Dov MurikIf the efi_secret module is built, register a late_initcall in the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load the efi_secret module.
This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
--- drivers/firmware/efi/Makefile | 1 + drivers/firmware/efi/coco.c | 58 ++++++++++++++++++++ drivers/virt/coco/efi_secret/Kconfig | 3 + 3 files changed, 62 insertions(+)
drivers/firmware/efi/Makefile +1 -0
@@ -32,6 +32,7 @@ obj-$(CONFIG_APPLE_PROPERTIES) += apple-properties.o obj-$(CONFIG_EFI_RCI2_TABLE) += rci2-table.o obj-$(CONFIG_EFI_EMBEDDED_FIRMWARE) += embedded-firmware.o obj-$(CONFIG_LOAD_UEFI_KEYS) += mokvar-table.o +obj-$(CONFIG_EFI_COCO_SECRET) += coco.o fake_map-y += fake_mem.o fake_map-$(CONFIG_X86) += x86_fake_mem.o
drivers/firmware/efi/coco.c new file +58 -0
58 lines not on this page · raw message
drivers/virt/coco/efi_secret/Kconfig +3 -0
@@ -14,3 +14,6 @@ config EFI_SECRET To compile this driver as a module, choose M here. The module will be called efi_secret. + + The module is loaded automatically by the EFI driver if the EFI + secret area is populated.
Signature · 1 line
2.25.1
Ard Biesheuvel
maintainerRe: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Quoted 11 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>
It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using platform_device_register_simple()
Quoted 96 lines
--- drivers/firmware/efi/Makefile | 1 + drivers/firmware/efi/coco.c | 58 ++++++++++++++++++++ drivers/virt/coco/efi_secret/Kconfig | 3 + 3 files changed, 62 insertions(+)drivers/firmware/efi/Makefile +1
-0@@ -32,6 +32,7 @@ obj-$(CONFIG_APPLE_PROPERTIES) += apple-properties.o obj-$(CONFIG_EFI_RCI2_TABLE) += rci2-table.o obj-$(CONFIG_EFI_EMBEDDED_FIRMWARE) += embedded-firmware.o obj-$(CONFIG_LOAD_UEFI_KEYS) += mokvar-table.o +obj-$(CONFIG_EFI_COCO_SECRET) += coco.o fake_map-y += fake_mem.o fake_map-$(CONFIG_X86) += x86_fake_mem.odrivers/firmware/efi/coco.c new file +58
-0@@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Confidential computing (coco) secret area handling +* +* Copyright (C) 2021 IBM Corporation +* Author: Dov Murik <[email protected]> +*/ + +#define pr_fmt (fmt) "efi: " fmt + +#include <linux/efi.h> +#include <linux/init.h> +#include <linux/io.h> +#include <linux/kmod.h> + +#ifdef CONFIG_EFI_SECRET_MODULE + +/* +* Load the efi_secret module if the EFI secret area is populated +*/ +static int __init load_efi_secret_module (void ) +{ +struct linux_efi_coco_secret_area *area; +efi_guid_t *header_guid; +int ret =0 ; + +if (efi.coco_secret ==EFI_INVALID_TABLE_ADDR ) +return 0 ; + + area =memremap (efi.coco_secret,sizeof (*area),MEMREMAP_WB ); +if (!area) { +pr_err ("Failed to map confidential computing secret area descriptor\n" ); +return -ENOMEM ; + } +if (!area->base_pa || area->size <sizeof (*header_guid)) + goto unmap_desc; + + header_guid = (void __force *)ioremap_encrypted (area->base_pa,sizeof (*header_guid)); +if (!header_guid) { +pr_err ("Failed to map secret area\n" ); + ret = -ENOMEM ; + goto unmap_desc; + } +if (efi_guidcmp (*header_guid,EFI_SECRET_TABLE_HEADER_GUID )) + goto unmap_encrypted; + + ret =request_module ("efi_secret" ); + +unmap_encrypted: +iounmap ((void __iomem *)header_guid); + +unmap_desc: +memunmap (area); +return ret; +} +late_initcall (load_efi_secret_module); + +#endif drivers/virt/coco/efi_secret/Kconfig +3
-1@@ -14,3 +14,6 @@ config EFI_SECRET To compile this driver as a module, choose M here. The module will be called efi_secret. + + The module is loaded automatically by the EFI driver if the EFI + secret area is populated. --2.25.1
Re: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Quoted 10 lines · Ard Biesheuvel
Quoted 9 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Quoted 9 lines
Quoted 2 lines
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using
platform_device_register_simple()
Thanks Ard, I'll look into this.
I hope the mechanism you suggest allows me to perform complex check to see if the device is really there (in this case: check for an efi variable, map memory as encrypted, verify it starts with a specific GUID -- everything before request_module() in the code below).
-Dov
Quoted 97 lines
Quoted 97 lines
--- drivers/firmware/efi/Makefile | 1 + drivers/firmware/efi/coco.c | 58 ++++++++++++++++++++ drivers/virt/coco/efi_secret/Kconfig | 3 + 3 files changed, 62 insertions(+)drivers/firmware/efi/Makefile +1
-0@@ -32,6 +32,7 @@ obj-$(CONFIG_APPLE_PROPERTIES) += apple-properties.o obj-$(CONFIG_EFI_RCI2_TABLE) += rci2-table.o obj-$(CONFIG_EFI_EMBEDDED_FIRMWARE) += embedded-firmware.o obj-$(CONFIG_LOAD_UEFI_KEYS) += mokvar-table.o +obj-$(CONFIG_EFI_COCO_SECRET) += coco.o fake_map-y += fake_mem.o fake_map-$(CONFIG_X86) += x86_fake_mem.odrivers/firmware/efi/coco.c new file +58
-0@@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Confidential computing (coco) secret area handling +* +* Copyright (C) 2021 IBM Corporation +* Author: Dov Murik <[email protected]> +*/ + +#define pr_fmt (fmt) "efi: " fmt + +#include <linux/efi.h> +#include <linux/init.h> +#include <linux/io.h> +#include <linux/kmod.h> + +#ifdef CONFIG_EFI_SECRET_MODULE + +/* +* Load the efi_secret module if the EFI secret area is populated +*/ +static int __init load_efi_secret_module (void ) +{ +struct linux_efi_coco_secret_area *area; +efi_guid_t *header_guid; +int ret =0 ; + +if (efi.coco_secret ==EFI_INVALID_TABLE_ADDR ) +return 0 ; + + area =memremap (efi.coco_secret,sizeof (*area),MEMREMAP_WB ); +if (!area) { +pr_err ("Failed to map confidential computing secret area descriptor\n" ); +return -ENOMEM ; + } +if (!area->base_pa || area->size <sizeof (*header_guid)) + goto unmap_desc; + + header_guid = (void __force *)ioremap_encrypted (area->base_pa,sizeof (*header_guid)); +if (!header_guid) { +pr_err ("Failed to map secret area\n" ); + ret = -ENOMEM ; + goto unmap_desc; + } +if (efi_guidcmp (*header_guid,EFI_SECRET_TABLE_HEADER_GUID )) + goto unmap_encrypted; + + ret =request_module ("efi_secret" ); + +unmap_encrypted: +iounmap ((void __iomem *)header_guid); + +unmap_desc: +memunmap (area); +return ret; +} +late_initcall (load_efi_secret_module); + +#endif drivers/virt/coco/efi_secret/Kconfig +3
-1@@ -14,3 +14,6 @@ config EFI_SECRET To compile this driver as a module, choose M here. The module will be called efi_secret. + + The module is loaded automatically by the EFI driver if the EFI + secret area is populated. --2.25.1
Ard Biesheuvel
maintainerRe: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Quoted 24 lines · Dov Murik
Quoted 10 lines · Ard Biesheuvel
Quoted 9 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Quoted 9 lines
Quoted 2 lines
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using
platform_device_register_simple()
Quoted 7 lines
Thanks Ard, I'll look into this.
I hope the mechanism you suggest allows me to perform complex check to see if the device is really there (in this case: check for an efi variable, map memory as encrypted, verify it starts with a specific GUID -- everything before
request_module()in the code below).
There is the device part and the driver part. Some of this belongs in the core code that registers the platform device, and some of it belongs in the driver. At this point, it probably does not matter that much which side does what, as the platform driver simply probes and can perform whatever check it needs, as long as it can back out gracefully (although I understand that, in this particular case, there are reasons why the driver may decide to wipe the secret)
Re: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Hello Ard,
Quoted 33 lines · Ard Biesheuvel
Quoted 24 lines · Dov Murik
Quoted 10 lines · Ard Biesheuvel
Quoted 9 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Quoted 9 lines
Quoted 2 lines
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using
platform_device_register_simple()Quoted 7 lines
Thanks Ard, I'll look into this.
I hope the mechanism you suggest allows me to perform complex check to see if the device is really there (in this case: check for an efi variable, map memory as encrypted, verify it starts with a specific GUID -- everything before
request_module()in the code below).
Quoted 7 lines
There is the device part and the driver part. Some of this belongs in the core code that registers the platform device, and some of it belongs in the driver. At this point, it probably does not matter that much which side does what, as the platform driver simply probes and can perform whatever check it needs, as long as it can back out gracefully (although I understand that, in this particular case, there are reasons why the driver may decide to wipe the secret)
I finally got to implement this, it seems like it makes the code simple. Thanks for the advice.
Just making sure I understand correctly: in this approach this we rely on udev to load the efi_secret module (aliased as "platform:efi_secret") and call its .probe() function? If there's no udev, the module will not be loaded automatically. Did I understand that correctly?
In such a case, the only thing needed to add in efi.c is:
drivers/firmware/efi/efi.c +3 -0
@@ -425,6 +425,9 @@ static int __init efisubsys_init(void)if (efi_enabled (EFI_DBG ) &&efi_enabled (EFI_PRESERVE_BS_REGIONS ))efi_debugfs_init (); +if (efi.coco_secret !=EFI_INVALID_TABLE_ADDR ) +platform_device_register_simple ("efi_secret" ,0 ,NULL ,0 ); +return 0 ; err_remove_group:
Does this seem OK? (before I re-spin the whole series.)
Thanks,
-Dov
Ard Biesheuvel
maintainerRe: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Quoted 45 lines · Dov Murik
Hello Ard,
Quoted 33 lines · Ard Biesheuvel
Quoted 24 lines · Dov Murik
Quoted 10 lines · Ard Biesheuvel
Quoted 9 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Quoted 9 lines
Quoted 2 lines
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using
platform_device_register_simple()Quoted 7 lines
Thanks Ard, I'll look into this.
I hope the mechanism you suggest allows me to perform complex check to see if the device is really there (in this case: check for an efi variable, map memory as encrypted, verify it starts with a specific GUID -- everything before
request_module()in the code below).Quoted 7 lines
There is the device part and the driver part. Some of this belongs in the core code that registers the platform device, and some of it belongs in the driver. At this point, it probably does not matter that much which side does what, as the platform driver simply probes and can perform whatever check it needs, as long as it can back out gracefully (although I understand that, in this particular case, there are reasons why the driver may decide to wipe the secret)
Quoted 8 lines
I finally got to implement this, it seems like it makes the code simple. Thanks for the advice.
Just making sure I understand correctly: in this approach this we rely on udev to load the
efi_secretmodule (aliased as "platform:efi_secret") and call its .probe() function? If there's no udev, the module will not be loaded automatically. Did I understand that correctly?
Apologies, I am swamped in email and only spotted this now.
This looks good to me: is this what you implemented in the end?
Re: [PATCH v8 3/4] efi: Load efi_secret module if EFI secret area is populated
Quoted 55 lines · Ard Biesheuvel
Quoted 45 lines · Dov Murik
Hello Ard,
Quoted 33 lines · Ard Biesheuvel
Quoted 24 lines · Dov Murik
Quoted 10 lines · Ard Biesheuvel
Quoted 9 lines · Dov Murik
If the
efi_secretmodule is built, register alate_initcallin the EFI driver which checks whether the EFI secret area is available and populated, and then requests to load theefi_secretmodule.This will cause the <securityfs>/secrets/coco directory to appear in guests into which secrets were injected; in other cases, the module is not loaded.
Quoted 9 lines
Quoted 2 lines
Signed-off-by Dov Murik <[email protected]>Reviewed-by Gerd Hoffmann <[email protected]>It would be better to simply expose a platform device and associated driver, instead of hooking into the module machinery directly.
We already do something similar for the EFI rtc and the efivars subsystem, using
platform_device_register_simple()Quoted 7 lines
Thanks Ard, I'll look into this.
I hope the mechanism you suggest allows me to perform complex check to see if the device is really there (in this case: check for an efi variable, map memory as encrypted, verify it starts with a specific GUID -- everything before
request_module()in the code below).Quoted 7 lines
There is the device part and the driver part. Some of this belongs in the core code that registers the platform device, and some of it belongs in the driver. At this point, it probably does not matter that much which side does what, as the platform driver simply probes and can perform whatever check it needs, as long as it can back out gracefully (although I understand that, in this particular case, there are reasons why the driver may decide to wipe the secret)
Quoted 8 lines
I finally got to implement this, it seems like it makes the code simple. Thanks for the advice.
Just making sure I understand correctly: in this approach this we rely on udev to load the
efi_secretmodule (aliased as "platform:efi_secret") and call its .probe() function? If there's no udev, the module will not be loaded automatically. Did I understand that correctly?
Quoted 3 lines
Apologies, I am swamped in email and only spotted this now.
This looks good to me: is this what you implemented in the end?
Yes indeed. So this old patch 3 was replaced by this much simpler code in the next iteration (v9):
drivers/firmware/efi/efi.c +3 -0
@@ -425,6 +425,9 @@ static int __init efisubsys_init(void)if (efi_enabled (EFI_DBG ) &&efi_enabled (EFI_PRESERVE_BS_REGIONS ))efi_debugfs_init (); +if (efi.coco_secret !=EFI_INVALID_TABLE_ADDR ) +platform_device_register_simple ("efi_secret" ,0 ,NULL ,0 ); +return 0 ; err_remove_group:
(this is were I missed the #ifdef CONFIG_EFI_COCO_SECRET ).
Thanks again for the suggestion.
-Dov
PATCH v8 4/4 docs: security: Add secrets/coco documentation
In reply to Dov MurikAdd documentation for the efi_secret module which allows access to Confidential Computing injected secrets.
--- Documentation/security/index.rst | 1 + Documentation/security/secrets/coco.rst | 103 ++++++++++++++++++++ Documentation/security/secrets/index.rst | 9 ++ 3 files changed, 113 insertions(+)
Documentation/security/index.rst +1 -0
@@ -17,3 +17,4 @@ Security Documentation tpm/index digsig landlock + secrets/index
Documentation/security/secrets/coco.rst new file +103 -0
103 lines not on this page · raw message
Documentation/security/secrets/index.rst new file +9 -0
@@ -0,0 +1,9 @@ +.. SPDX-License-Identifier: GPL-2.0 + +===================== +Secrets documentation +===================== + +.. toctree:: + + coco
Signature · 1 line
2.25.1
Quoted 11 lines · Dov Murik
Confidential computing (coco) hardware such as AMD SEV (Secure Encrypted Virtualization) allows guest owners to inject secrets into the VMs memory without the host/hypervisor being able to read them. In SEV, secret injection is performed early in the VM launch process, before the guest starts running.
OVMF already reserves designated area for secret injection (in its AmdSev package; see edk2 commit
01726b6d23d4"OvmfPkg/AmdSev: Expose the Sev Secret area using a configuration table" [1]), but the secrets were not available in the guest kernel.
Quoted 4 lines
The patch series keeps the address of the EFI-provided memory for injected secrets, and exposes the secrets to userspace via securityfs using a new
efi_secretkernel module. The module is autoloaded (by the EFI driver) if the secret area is populated.
Right, so this thing.
Tom and I were talking about SEV* guest debugging today and I believe there might be another use case for this: SEV-ES guests cannot find out from an attestation report - like SNP guests can - whether they're being debugged or not so it would be very helpful if the fact that a -ES guest is being debugged, could be supplied through such a secrets blob.
Because then, when I'm singlestepping the guest with gdb over the gdbstub, the guest could determine based on those guest-owner previously injected secrets whether it should allow debugging or not.
And this is where your set comes in.
However, I'm wondering if - instead of defining your own secrets structs etc - you could use the SNP confidential computing blob machinery the SNP set is adding. In particular:
https://lore.kernel.org/all/[email protected]/
And you're adding another GUID but maybe you could simply use the SNP thing called EFI_CC_BLOB_GUID and mimick that layout.
That should unify things more. And then guest kernel code could query the blob also for debugging policy and so on.
Thoughts, opinions?
Signature · 4 lines
Regards/Gruss,
Boris.
SUSE Software Solutions Germany GmbH, GF: Ivo Totev, HRB 36809, AG NürnbergHello Boris,
Quoted 25 lines · Borislav Petkov
Quoted 11 lines · Dov Murik
Confidential computing (coco) hardware such as AMD SEV (Secure Encrypted Virtualization) allows guest owners to inject secrets into the VMs memory without the host/hypervisor being able to read them. In SEV, secret injection is performed early in the VM launch process, before the guest starts running.
OVMF already reserves designated area for secret injection (in its AmdSev package; see edk2 commit
01726b6d23d4"OvmfPkg/AmdSev: Expose the Sev Secret area using a configuration table" [1]), but the secrets were not available in the guest kernel.Quoted 4 lines
The patch series keeps the address of the EFI-provided memory for injected secrets, and exposes the secrets to userspace via securityfs using a new
efi_secretkernel module. The module is autoloaded (by the EFI driver) if the secret area is populated.Right, so this thing.
Tom and I were talking about SEV* guest debugging today and I believe there might be another use case for this: SEV-ES guests cannot find out from an attestation report - like SNP guests can - whether they're being debugged or not so it would be very helpful if the fact that a -ES guest is being debugged, could be supplied through such a secrets blob.
Quoted 4 lines
Because then, when I'm singlestepping the guest with gdb over the gdbstub, the guest could determine based on those guest-owner previously injected secrets whether it should allow debugging or not.
Let's see if I understand this correctly:
You want the guest to know if the its own SEV VM policy allows debugging. And that flag has to be trusted -- so passed from the Guest Owner in a secure channel (otherwise the host could set it to ALLOW_DEBUGGING even though the Guest Owner didn't approve that).
Quoted 6 lines
And this is where your set comes in.
However, I'm wondering if - instead of defining your own secrets structs etc - you could use the SNP confidential computing blob machinery the SNP set is adding. In particular:
Quoted 8 lines
https://lore.kernel.org/all/[email protected]/
And you're adding another GUID but maybe you could simply use the SNP thing called
EFI_CC_BLOB_GUIDand mimick that layout.That should unify things more. And then guest kernel code could query the blob also for debugging policy and so on.
Maybe you could do that, but that will unify things that are not the same, so I think it is the wrong approach here.
The SNP secrets are secrets generated by the AMD-SP and allow the guest to communicate with the PSP. There are exactly 4 of them (if I remember correctly) and they are only AES-256-GCM keys (if I remember correctly).
On the other hand, the SEV launch secrets (which this series is about) are secrets populated by the Guest Owner and are intended for the proper operation of the applications in the guest (example use cases: luks passphrase, secret API keys, file decryption keys, encrypted container images keys, ...).
The SEV launch secrets area can also be read by grub [1], for example, to fetch a luks passphrase from there (instead of from keyboard). That's why its structure is generic.
[1] https://lists.gnu.org/archive/html/grub-devel/2022-02/msg00066.html
Quoted 2 lines
Thoughts, opinions?
I think Guest Owner can add a 1-byte predefined secret to the SEV secret table, let's say an entry with GUID 2b91a212-b0e1-4816-b021-1e9991ddb6af and value "\x01" to indicate debugging is allowed.
With the efi_secrets module, a 1-byte file called /sys/kernel/security/secrets/coco/2b91a212-b0e1-4816-b021-1e9991ddb6af will appear with "\x01" in its content.
This can indicate to the guest that debugging was permitted by the Guest Owner.
If you want this unified in the kernel, maybe we can look for this entry and set the relevant kernel variable.
-Dov
Hi Dov,
Quoted 6 lines · Dov Murik
Let's see if I understand this correctly:
You want the guest to know if the its own SEV VM policy allows debugging. And that flag has to be trusted -- so passed from the Guest Owner in a secure channel (otherwise the host could set it to
ALLOW_DEBUGGINGeven though the Guest Owner didn't approve that).
Yeah, and then dump all the guest memory and thus bypass the whole memory encryption fun. So yeah, it should be encrypted and accessible only to the guest and supplied by the guest owner.
Quoted 3 lines
The SEV launch secrets area can also be read by grub [1], for example, to fetch a luks passphrase from there (instead of from keyboard). That's why its structure is generic.
Ok, fair enough.
Quoted 6 lines
I think Guest Owner can add a 1-byte predefined secret to the SEV secret table, let's say an entry with GUID 2b91a212-b0e1-4816-b021-1e9991ddb6af and value "\x01" to indicate debugging is allowed.
With the
efi_secretsmodule, a 1-byte file called/sys/kernel/security/secrets/coco/2b91a212-b0e1-4816-b021-1e9991ddb6af
I'd love it if that were more user-friendly:
/sys/kernel/security/secrets/coco/attributes
and there's:
debugging:1
...
and others.
Quoted 4 lines
will appear with "\x01" in its content.
This can indicate to the guest that debugging was permitted by the Guest Owner.
But yeah, that should be the gist of the functionality.
Quoted 2 lines
If you want this unified in the kernel, maybe we can look for this entry and set the relevant kernel variable.
So now that I think of it, it would be even nicer if the fact whether guest debugging is allowed, were available to the guest *very early* during boot. Because I think the most important cases where you'd want to singlestep a SEV* guest with the qemu gdbstub is early guest kernel boot code. So it would be cool if we'd have access to the debugging setting that early.
Lemme have a look at your patches in detail to get an idea what's happening there.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
SUSE Software Solutions Germany GmbH, GF: Ivo Totev, HRB 36809, AG NürnbergQuoted 10 lines · Borislav Petkov
So now that I think of it, it would be even nicer if the fact whether guest debugging is allowed, were available to the guest *very early* during boot. Because I think the most important cases where you'd want to singlestep a SEV* guest with the qemu gdbstub is early guest kernel boot code. So it would be cool if we'd have access to the debugging setting that early.
Lemme have a look at your patches in detail to get an idea what's happening there.
Is efi_config_parse_tables() early enough? That's where we learn for the first time that the firmware has a launch-secrets area that we can look at.
We can add there (say, next to the call to efi_tpm_eventlog_init()) a code to:
1. map the secret area (ioremap_encrypted())
2. parse the table, look for the "sev debug enabled" GUID.
3. set the value of the kernel variable that we can later use anywhere.
Of course Ard might know about a better mechanism or place to do that.
-Dov
Quoted 12 lines · Dov Murik
Quoted 8 lines · Borislav Petkov
So now that I think of it, it would be even nicer if the fact whether guest debugging is allowed, were available to the guest *very early* during boot. Because I think the most important cases where you'd want to singlestep a SEV* guest with the qemu gdbstub is early guest kernel boot code. So it would be cool if we'd have access to the debugging setting that early.
Quoted 3 lines
Quoted 2 lines
Lemme have a look at your patches in detail to get an idea what's happening there.
After a night's sleep I figured out that an SEV guest cannot tell if a value it's reading was (a) encrypted by the host using KVM_SEV_LAUNCH_UPDATE_DATA, or (b) added using secret injection using KVM_SEV_LAUNCH_SECRET.
The only difference is that if the host is using KVM_SEV_LAUNCH_UPDATE_DATA, then it changes the measurement. But maybe for debugging scenarios we (= Guest Owner) don't care about the measurement being correct.
If that's the case, we don't need a secure channel and secret injection. You can use a simple "sev=debug" (or whatever) in the kernel command-line to indicate your needs.
Did I miss something?
-Dov
Quoted 3 lines · Dov Murik
If that's the case, we don't need a secure channel and secret injection. You can use a simple "sev=debug" (or whatever) in the kernel command-line to indicate your needs.
Yeah, that would work for a normal SEV guest.
However, if it is an -ES guest, you need to somehow tell it as the guest
owner: "hey you're being debugged and that's fine."
Because if you want to singlestep the thing, you're going to land in the #VC handler and destroy registers so you want to save them first if you're being debugged and then shovel them out to the host somehow. And that's another question but first things first.
And "if you're being debugged" needs to be somehow told the guest through a secure channel so that the HV doesn't go and simply enable debugging by booting with "sev=debug" and bypass it all.
And SNP has access to the policy in the attestation report, says Tom, so that's possible there.
So we need a way to add the debugging aspect to the measurement and be able to recreate that measurement quickly so that a simple debugging session of a kernel in a guest can work pretty much the same with a SEV* guest.
I'm still digging the details tho...
Signature · 4 lines
Regards/Gruss,
Boris.
SUSE Software Solutions Germany GmbH, GF: Ivo Totev, HRB 36809, AG NürnbergQuoted 10 lines · Borislav Petkov
Quoted 3 lines · Dov Murik
If that's the case, we don't need a secure channel and secret injection. You can use a simple "sev=debug" (or whatever) in the kernel command-line to indicate your needs.
Yeah, that would work for a normal SEV guest.
However, if it is an -ES guest, you need to somehow tell it as the guest
owner: "hey you're being debugged and that's fine."
Quoted 9 lines
Because if you want to singlestep the thing, you're going to land in the #VC handler and destroy registers so you want to save them first if you're being debugged and then shovel them out to the host somehow. And that's another question but first things first.
And "if you're being debugged" needs to be somehow told the guest through a secure channel so that the HV doesn't go and simply enable debugging by booting with "sev=debug" and bypass it all.
Note that the HV can also start the VM with SEV completely turned off. Similarly, it can enable debugging and "fool" the guest. Of course all this tricks will affect the measurement, and then the Guest Owner will know that something is wrong and won't inject the secrets. If you don't rely on secret injection anyway, then I think a kernel command-line param is good enough. (I might be missing a scenario though)
Maybe you can use KVM_SEV_GET_ATTESTATION_REPORT (ask the host to do it for you). But I think it returns only the launch digest, and you can't figure out the SEV Policy field from it.
Quoted 2 lines
And SNP has access to the policy in the attestation report, says Tom, so that's possible there.
True. But not in really early boot? This is all in the sev-guest platform driver.
Quoted 8 lines
So we need a way to add the debugging aspect to the measurement and be able to recreate that measurement quickly so that a simple debugging session of a kernel in a guest can work pretty much the same with a SEV* guest.
I'm still digging the details tho...