Skip to contentSkip to conversation

Secure IPL Support for SCSI Scheme of virtio-blk/virtio-scsi Devices

PATCH Superseded Zhuoying Cai 7 participants 73 messages May 5 – Jun 11

Subsystems (2)

v11 of 17 Superseded Latest is v17 →

lore
Share & tools
lore
#0 lore raw

v11 cover Secure IPL Support for SCSI Scheme of virtio-blk/virtio-scsi Devices

Changelog v10->v11

crypto/x509-utils
- Replaced gnutls_free() with g_free()
- Reviewed-by: Daniel P. Berrangé <[email protected]>

[PATCH v10 07/30] s390x/diag: Implement DIAG 320 subcode 1
- Defined VCEntryHeader and VCBlockHeader
- Replaced header length macros with sizeof(...)

[PATCH v10 09/30] s390x/diag: Implement DIAG 320 subcode 2
- Split VCB and VCE into separate header and buffer structures

[NEW] hw/s390x: Define finite size for single entry VCEntry
- Introduced size limits for VCEntry
* Defined MAX_ENTRY_SIZE as 8 KB
* Defined CERT_BUF_MAX_LEN as MAX_ENTRY_SIZE - sizeof(VCEntryHeader)
- Updated update_cert_store()
* Enforced certificate buffer size limit using CERT_BUF_MAX_LEN

[PATCH v10 13/30] s390x/ipl: Introduce IPL Information Report Block (IIRB)
- Adjusted IplDeviceComponentList sizing
* Used MAX_COMP_ENTRIES =
(largest supported block size - 32) / 32

[PATCH v10 14/30] pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers
- Reviewed-by: Farhan Ali <[email protected]>

[PATCH v10 15/30] hw/s390x/ipl: Add IPIB flags to IPL Parameter Block
- Removed duplicated S390_IPL_TYPE* definitions
- Moved IPLB length definitions to qipl.h

[PATCH v10 17/30] pc-bios/s390-ccw: Refactor zipl_run()
- Reviewed-by: Jared Rossi <[email protected]>

[PATCH v10 18/30] pc-bios/s390-ccw: Rework zipl_load_segment function
- Used block_number_t blockno and uint64_t address parameters

[NEW] pc-bios/s390-ccw: Introduce ZiplBootMode for IPL mode selection
- Added ZiplBootMode enum
* Introduced Normal mode
* Performed IPL validation based on selected boot mode

[PATCH v10 19/30] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Refactored list_add helpers
* cert_list_add() printed warning once at limit and returned index
* comp_list_add() panicked on overflow
- zipl_load_signature()
* Renamed sig_sec -> sig
* Reordered condition checks
- zipl_run_secure()
* Renamed cert_addr -> cert_buf
* Used SecureIplCompEntryInfo for signature metadata
* Renamed label out -> error
- Moved secure IPL checks earlier in flow
- DIAG320 updates
* Renamed diag320 -> _diag320
* Replaced vcssb_data[] with VCStorageSizeBlock
* Replaced vcb_data[] with local VCBlock containing one VCE and cert_data[MAX_SIZE]
* Panicked if remain_ct != 0
- Renamed zipl_secure_handle() -> zipl_secure_error()

[PATCH v10 20/30] pc-bios/s390-ccw: Add signed component address overlap checks
- comp_addr_range_add()
* Returned early when array limit was reached
* Moved index increment into this function
- Renamed is_comp_overlap -> check_comp_overlap
- SecureIplCompAddrRangeList
* Renamed index -> num
* Adjusted array size to MAX_COMP_ENTRIES

[PATCH v10 22/30] pc-bios/s390-ccw: Add additional security checks for secure boot
- Refactored validate_comp_condition()
* Renamed to zipl_secure_validate()
* Replaced functions with a single check with zipl_secure_validate()
- Renamed SCLAB flags and SCLAB structure
- Reworked sclp_get_fac_ipl()
* Renamed to sclp_is_fac_ipl_flag_on()
* Accepted flags parameter and returned masked result

[PATCH v10 24/30] hw/s390x/ipl: Set IPIB flags for secure IPL
- Reviewed-by: Collin Walling <[email protected]>

[PATCH v10 25/30] pc-bios/s390-ccw: Handle true secure IPL mode
- Reported missing SCLAB in audit mode

Documentation
- Fixed title hierarchy issues
- Added link to referenced document
- Clarified zipl must run on guest filesystem

------------------------------------------------------------------------

# Description

This patch series is an external requirement by Linux distribution partners to verify secure IPL process. Additional secure IPL checks are also included in this series to address security holes in the original secure IPL design to prevent malicious actors to boot modified or unsigned code despite secure IPL being enforced.

Secure IPL is enabled when the QEMU options for secure IPL are specified in the command line.

During this process, additional security checks are performed to ensure system integrity.

As components are loaded from disk, DIAG 508 subcode 2 performs signature verification if a signature entry is identified. Upon successful verification, DIAG 320 subcode 2 will request the corresponding certificate from QEMU key store to the BIOS.

Secure IPL will continue until all the components are loaded if no error occurs during True secure IPL mode or in Audit mode (see explanation below).

After that, an IPL Information report block (IIRB) is initialized immediately following an IPL Parameter Information Block. The IIRB is populated with information about the components, verification results and certificate data.

Finally, the guest system proceeds to boot.

Only List-Directed-IPL contains the relevant zIPL data structures to perform secure IPL. This patch series only adds support for the SCSI scheme of virtio-blk/virtio-scsi devices. Secure IPL for other device types will be considered as follow-up work at a later date.

** Note: "secure IPL" and "secure boot" are used interchangeably throughout the design. **

# True Secure IPL Mode and Audit Mode

## True Secure IPL Mode

When secure IPL is enabled and certificates are provided, all the secure IPL checks will performed. The boot process will abort if any error occurs during the secure IPL checks.

## Audit Mode

When the secure IPL option is not selected and certificates are provided, all the secure IPL checks will still be performed. However, the boot process will continue if any errors occur, with messages logged to the console during the secure IPL checks.

The audit mode is also considered as simulated secure IPL because it is less pervasive, and allows the guest to boot regardless of the secure checking results.

# How to Enable Secure IPL

## QEMU Build Notes

When building QEMU, enable the cryptographic libraries.

Run configure script in QEMU repository with either parameter:

	./configure … --enable-gnutls

## Create Certificates via certtool

Generate and use an RSA private key for signing.

	certtool --generate-privkey > key.pem

A self-signed certificate requires the organization name. Use the cert.info template to pre-fill values and avoid interactive prompts from certtool.

	cat > cert.info <<EOF
	cn = "My Name"
	expiration_days = 36500
	cert_signing_key
	EOF

	certtool --generate-self-signed \
		 --load-privkey key.pem \
		 --template cert.info \
		 --hash=SHA256 \
		 --outfile cert.pem

It is recommended to store the certificate(s) in the /…/qemu/certs directory for easy identification.

## Sign Kernel and Prepare zipl

All actions must be performed on a guest.

Copy the sign-file script (located in Linux source repository), generated private key(s), and certificate(s) to guest's file system.

Sign guest image(s) and stage3 binary:

	./sign-file sha256 key.pem cert.pem /boot/vmlinuz-…

	./sign-file sha256 key.pem cert.pem /usr/lib/s390-tools/stage3.bin

Run zipl with secure boot enabled.

	zipl --secure 1 -V

Guest image(s) are now signed, stored on disk, and can be verified.

## New QEMU Command Options for Secure IPL

New parameters have been added to the s390-ccw-virtio machine type to enable Secure IPL and provide certificates for signature verification.

This parameter enables or disables Secure IPL/boot. If not specified, it defaults to off.

	qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on|off

This parameter specifies one or more paths to boot certificates, used for signature verification. You can provide a single certificate file or a directory.

	qemu-system-s390x -machine s390-ccw-virtio, \
                                   boot-certs.0.path=/.../qemu/certs, \
                                   boot-certs.1.path=/another/path/cert.pem

Example:

	qemu-system-s390x -machine s390-ccw-virtio,
	                           secure-boot=on, \
	                           boot-certs.0.path=/.../qemu/certs, \
                                   boot-certs.1.path=/another/path/cert.pem

Secure IPL command options overview:

If neither the -secure-boot nor the -boot-certs options are specified, the guest will boot in normal mode, and no security checks will be conducted.

If the -secure-boot option is not specified or is set to off, and the -boot-certs option is provided, the guest will boot in audit mode. In this mode, all security checks are performed; however, any errors encountered will not interrupt the boot process.

If the -secure-boot option is set to on and the -boot-certs option is provided, the guest will boot in true secure IPL mode. In this mode, all security checks are performed, and any errors encountered will terminate the boot process.
- If the -boot-certs option is not provided in true secure IPL mode, the boot process will fail for the corresponding device.

## Constraints

- z16 or "qemu" CPU model

- certificates must be in X.509 PEM format

- only support for SCSI scheme of virtio-blk/virtio-scsi devices
- The boot process will terminate if secure boot is enabled without
specifying a boot device.
- If enabling secure boot with multiple boot devices, any
unsupported devices or non-eligible devices will cause the entire boot process terminating early with an error logged to the console.

- attempting to perform secure IPL outside of these constraints will result in a failure.

# DIAGNOSE 508 - IPL Extensions

Signature verification is performed during IPL via DIAG 508. Component address, component length, signature address and signature length are obtained in the BIOS and pass to DIAG 508 subcode 2 to perform signature verification in QEMU. If verification succeeds, DIAG 508 subcode 2 (signature verification) will return the length and index of the certificate in the QemuCertificateStore that was used for verification.

## Data Structures

Diag508SignatureVerificationBlock (SVB) — stores addresses and lengths of the component and signature to be used for signature verification. Upon verification, an index and the length of the certificate used is stored.

------------------------------------------------------------------------

Changelog v9->v10

[PATCH v9 09/30] s390x/diag: Implemented DIAG 320 subcode 2
- Reworded documentation.
- Used vce->len directly from handle_diag320_store_vc().
- Dropped entry_offset; used vcb->out_len from handle_diag320_store_vc().

[PATCH v9 13/30] s390x/ipl: Introduced IPL Information Report Block (IIRB)
- Clarified IIRB in documentation and commit message.
- Reviewed-by: Collin Walling <[email protected]>

[PATCH v9 19/30] pc-bios/s390-ccw: Added signature verification for secure IPL in audit mode
- Removed trailing newline from sclp_get_fac_ipl().
- Zeroed VCB on error path in request_certificate() using memset().
- Introduced component-entry tracking struct to reduce parameter passing.
- Fixed signed/unsigned error-code mismatches in zipl_run_secure().
- Fixed sig_len/comp_len type mismatch causing negative error misinterpretation.
- Dropped unnecessary initialization of cert_len and cert_table_idx in zipl_run_secure().

[PATCH v9 20/30] pc-bios/s390-ccw: Added signed component address overlap checks
- Updated is_comp_overlap() comment.
- Tracked component ranges using SecureIplCompAddrRangeList.

[PATCH v9 22/30] pc-bios/s390-ccw: Added additional security checks for secure boot
- Refactored functions to reduce parameters.
- Renamed set_comp_cei_with_log() to validate_comp_condition() and returned a status flag.
- Renamed security-check helpers for clarity.
- check_nuc → check_no_unsigned_comp
- check_sc → check_single_comp
- check_signed_comp → check_has_signed_comp
- Added signed and unsigned counters to SecureIplSclabInfo.
- Added comment for SCLAB helper struct.

[PATCH v9 25/30] pc-bios/s390-ccw: Handled true secure IPL mode
- Removed ZIPL_BOOT_MODE_INVALID; failed immediately on invalid boot mode.
- Reviewed-by: Collin Walling <[email protected]>

Changelog v8->v9

Documentation
- Replaced "userspace" with "guest code".

[PATCH v8 01/30] Add boot-certs to s390-ccw-virtio machine type option
- Fixed typo and formatting issues in documentation.

[PATCH v8 04/30] hw/s390x/ipl: Create certificate store
- Fixed coding-style issues.
- Corrected the maximum certificate count check.
- Removed QEMU_BUILD_BUG_MSG from cert-store.h.
- Reviewed-by: Farhan Ali <[email protected]>

[PATCH v8 05/30] s390x/diag: Introduce DIAG 320 for Certificate Store Facility
- Updated documentation.
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 06/30] s390x/diag: Refactor address validation check from diag308_parm_check
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 07/30] s390x/diag: Implement DIAG 320 subcode 1
- Adjusted return code in handle_diag320_query_vcsi().
- Changed double-word boundary handling to use a specification interrupt rather than an address interrupt.

[PATCH v8 09/30] s390x/diag: Implement DIAG 320 subcode 2
- Fixed a build error caused by a missing include.
- Added a comment documenting VCE_INVALID_LEN usage.
- Enforced 4 KB alignment for the subcode 2 address.

[PATCH v8 12/30] s390x/diag: Implement DIAG 508 subcode 1 for signature verification
- Reviewed-by: Farhan Ali <[email protected]>

[PATCH v8 13/30] s390x/ipl: Introduce IPL Information Report Block (IIRB)
- Reviewed-by: Farhan Ali <[email protected]>

[PATCH v8 14/30] pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 16/30] s390x: Guest support for Secure-IPL Facility
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 19/30] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Corrected ROUND_UP usage and added a remark similar to the one in osdep.h.
- Merged sclp_is_diag320_on() and sclp_get_fac134().
- Declared vcssb_data as static.
- Ensured vcssb_data is double-word aligned as required by DIAG 320 subcode 1.
- Reset vcssb->length on errors (e.g., set to 0).
- Defined vcb_data as a static array with 4 KB alignment, as required by DIAG 320 subcode 2.
- Ensured the boot process exits when required facilities are missing in secure/audit mode.

[PATCH v8 20/30] pc-bios/s390-ccw: Add signed component address overlap checks
- Handled out-of-range component address range indices according to the active boot mode.

[PATCH v8 21/30] s390x: Guest support for Secure-IPL Code Loading Attributes Facility (SCLAF)
- Fixed a documentation build issue.

[PATCH v8 22/30] pc-bios/s390-ccw: Add additional security checks for secure boot
- Fixed coding-style issues.

[PATCH v8 24/30] hw/s390x/ipl: Set IPIB flags for secure IPL
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 25/30] pc-bios/s390-ccw: Handle true secure IPL mode
- Removed ZIPL_BOOT_MODE_INVALID case from zipl_run() and allowed the default case to handle it.

[PATCH v8 26/30] hw/s390x/ipl: Handle secure boot with multiple boot devices
- Reviewed-by: Thomas Huth <[email protected]>

[PATCH v8 28/30] tests/functional/s390x: Add secure IPL functional test
- Made the test executable (chmod a+x) to allow direct execution outside the Meson harness.
- Updated the test to operate on a copied asset using qemu-img -b.

Changelog v7->v8

- Edited documentation

[PATCH v7 01/29] Add boot-certs to s390-ccw-virtio machine type option
- Updated version number from 10.2 to 11.0

[PATCH v7 02/29] crypto/x509-utils: Refactor with GNUTLS fallback
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 03/29] crypto/x509-utils: Add helper functions for certificate store
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 04/29] hw/s390x/ipl: Create certificate store
- Merged init_cert_x509() with init_cert()
- Simplified certificate path handling; removed redundant NULL checks in get_cert_paths()
- Added warnings for empty certificate directories and non-.pem files
- Renamed variables: VC_* → CERT_* and max_cert_size → largest_cert_size
- Made certificate store initialization independent of kernel/IPLB state
- Fixed memory leak
- Added comments explaining why DER data is not stored in S390IPLCertificate

[PATCH v7 05/29] s390x/diag: Introduce DIAG 320 for Certificate Store Facility
- Simplified control flow in handle_diag_320()
- Removed the word "Provide" from description text

[PATCH v7 06/29] s390x/diag: Refactor address validation check from diag308_parm_check()
- Added Reviewed-by: Collin Walling <[email protected]>
- Added Reviewed-by: Hendrik Brueckner <[email protected]>

[PATCH v7 07/29] s390x/diag: Implement DIAG 320 subcode 1
- Added upper-bound validation for vcssb->length
- Added Reviewed-by: Collin Walling <[email protected]>

[PATCH v7 08/29] crypto/x509-utils: Add helper functions for DIAG 320 subcode 2
- Simplified ECC curve validation logic
- Moved public-key algorithm detection to internal helpers
- Removed unused QCRYPTO_PK_ALGO enum
- Fixed commit message

[PATCH v7 09/29] s390x/diag: Implement DIAG 320 subcode 2
- Added sanity checks for key ID retrieval; mark certificates invalid if extraction fails
- Reworked VCE construction logic
- Pass S390IPLCertificate as const pointers instead of copying structs

[PATCH v7 10/29] s390x/diag: Introduce DIAG 508 for secure IPL operations
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 11/29] crypto/x509-utils: Add helper functions for DIAG 508 subcode 1
- Fixed typos
- Added Reviewed-by: Thomas Huth <[email protected]>
- Added Reviewed-by: Farhan Ali <[email protected]>

[PATCH v7 12/29] s390x/diag: Implement DIAG 508 subcode 1 for signature verification
- Added comments on maximum component and signature lengths
- Added warning indicating failures due to oversize signature or component
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 13/29] pc-bios/s390-ccw: Introduce IPL Information Report Block (IIRB)
- Updated documentation describing guest kernel usage of certificate data in the IIRB
- Simplified and renamed flags and type definitions
- Merged unused and reserved fields
- Moved IIRB definitions from pc-bios/s390-ccw/iplb.h to include/hw/s390x/ipl/qipl.h

[PATCH v7 14/29] pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers
- Moved IplBlocks struct from pc-bios/s390-ccw/iplb.h to include/hw/s390x/ipl/qipl.h
- Moved attribute annotations to the ipl_data declaration in main.c

* Note: checkpatch.pl flags the following:

          ERROR: externs should be avoided in .c files
          #88: FILE: pc-bios/s390-ccw/main.c:26:
          +IplBlocks ipl_data __attribute__((__aligned__(PAGE_SIZE)));

This appears to be a false positive, as IplBlocks is not declared as an extern in a .c file, and checkpatch.pl reports the same warning for the existing IplParameterBlock declaration in main.c even before this patch.

[PATCH v7 15/29] hw/s390x/ipl: Add IPIB flags to IPL Parameter Block
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 16/29] s390x: Guest support for Secure-IPL Facility
- Fixed reserved-field off-by-one error

[PATCH v7 17/29] pc-bios/s390-ccw: Refactor zipl_run()
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 19/29] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Updated warning message
- Simplified control flow and error handling in zipl_run()
- Removed UNSPECIFIED boot mode and defaulted to NORMAL
- Refactored zipl_run_secure()
- Renamed variables and functions
- Adjusted index handling in verify_signature(), accounting for DIAG 320 when retrieving certificates

[PATCH v7 21/29] pc-bios/s390-ccw: Add additional security checks for secure boot
- Renamed constants:

    S390_IPL_INFO_IIEI_* → S390_IIEI_*
    S390_IPL_COMPONENT_CEI_* → S390_CEI_*

- Improved readability by reducing function parameter counts
- Fixed check_sc() to allow only a single signed binary component
- Moved address-range/overlap checks to a separate patch

[PATCH v7 22/29] Add secure-boot to s390-ccw-virtio machine type option
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 23/29] hw/s390x/ipl: Set IPIB flags for secure IPL
- Fixed commit message

[PATCH v7 24/29] pc-bios/s390-ccw: Handle true secure IPL mode
- Updated documentation
- Fixed typo

[PATCH v7 25/29] pc-bios/s390-ccw: Handle secure boot with multiple boot devices
- Handled support for multiple secure boot devices on the QEMU side

[PATCH v7 26/29] hw/s390x/ipl: Handle secure boot without a specified boot device
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v7 27/29] tests/functional/s390x: Add secure IPL
- Cleaned up test code
- Switched from time.sleep() to wait_for_console_pattern()

Changelog v6->v7

Add functional test for secure IPL

Secure IPL documentation
- Merged command line into one line
- Limited line length to 80 columns

[PATCH v6 01/28] Add boot-certs to s390-ccw-virtio machine type option
- Renamed BootCertificate to BootCertificates
- Added Acked-by: Markus Armbruster <[email protected]>

[PATCH v6 02/28] crypto/x509-utils: Refactor with GNUTLS fallback
- Edited commit message
- Added Acked-by: Daniel P. Berrangé <[email protected]>

[PATCH v6 03/28] crypto/x509-utils: Add helper functions for certificate store
- Added Acked-by: Daniel P. Berrangé <[email protected]>

[PATCH v6 04/28] hw/s390x/ipl: Create certificate store
- Removed QEMU_PAKCED
- Inlined cert2buf wrapper function to reduce lines of code
- Reported error and handled exit in s390_ipl_create_cert_store()

[PATCH v6 05/28] s390x/diag: Introduce DIAG 320 for Certificate Store Facility
- Fixed typos
- Added Reviewed-by: Farhan Ali <[email protected]>

[PATCH v6 06/28] s390x/diag: Refactor address validation check from diag308_parm_check
- Moved diag_parm_addr_valid() to target/s390x/diag.c
- Added Reviewed-by: Farhan Ali <[email protected]>

[PATCH v6 07/28] s390x/diag: Implement DIAG 320 subcode 1
- Added Reviewed-by: Farhan Ali <[email protected]>

[PATCH v6 08/28] crypto/x509-utils: Add helper functions for DIAG 320 subcode 2
- Edited commit message
- Handled negative return value from gnutls_x509_crt_get_pk_algorithm() in qcrypto_x509_get_pk_algorithm
- Checked boundary before using hash_alg in qcrypto_x509_get_cert_key_id()
- Rename qcrypto_x509_is_ecc_curve_p521() to qcrypto_x509_check_ecc_curve_p521()

[PATCH v6 09/28] s390x/diag: Implement DIAG 320 subcode 2
- Removed redundant set vce->len
- Added check to make sure data doesn't exceed buffer bounds

[PATCH v6 10/28] s390x/diag: Introduce DIAG 508 for secure IPL operations
- Reworded document to avoid the term “KVM”
- Added Reviewed-by: Farhan Ali <[email protected]>

[PATCH v6 11/28] crypto/x509-utils: Add helper functions for DIAG 508 subcode 1
- Fixed indentation
- Replaced g_new0() and memcpy() with g_memdup2()

[PATCH v6 12/28] s390x/diag: Implement DIAG 508 subcode 1 for signature verification
- Edit commit message and documentation in handle_diag508_sig_verif()
- Changed diag_508_verify_sig function return type from int to bool
- Set upper limit for comp_len and sig_len to avoid malicious memory allocation
- Fixed coding style - eliminate unnecessary variables

[PATCH v6 13/28] pc-bios/s390-ccw: Introduce IPL Information Report Block (IIRB)
- Removed bios structs packing

[PATCH v6 14/28] pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers
- specify ipl_data attribute in the pc-bios/s390-ccw/main.c

[PATCH v6 15/28] hw/s390x/ipl: Add IPIB flags to IPL Parameter Block
- Moved the setting of iplb->len to when the DIAG308_IPIB_FLAGS_IPLIR is set

[PATCH v6 17/28] pc-bios/s390-ccw: Refactor zipl_run()
- Preserved return error value from zipl_run_normal()

[PATCH v6 18/28] pc-bios/s390-ccw: Rework zipl_load_segment function
- Fixed typoes
- Added Reviewed-by: Thomas Huth <[email protected]>

[PATCH v6 19/28] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Edited documentation
- Removed bios structs packing
- Be more specific in the error message and mention Passthrough (vfio) CCW device does not support secure boot
- Allocated memory for vcb using max_single_vcb_len instead of MAX_SECTOR_SIZE in request_certificate()
- Rename variables in zipl_run_secure()
cert_index → cert_entry_idx
comp_index → comp_entry_idx
cert_idx → cert_table_idx
- Refactored handle_certificate(): only handles certificate related operations and moved the increment of cert_entry_idx and cert to zipl_run_secure()

[PATCH v6 21/28] pc-bios/s390-ccw: Add additional security checks for secure boot
- Fixed coding style
- Added out of range warning in comp_addr_range_add()
- Fixed end address issue in is_psw_valid() and is_comp_overlap()
- Inlined comparison functions

[PATCH v6 22/28] Add secure-boot to s390-ccw-virtio machine type option
- Moved bool secure_boot next to other bool variables to avoid additional padding

[PATCH v6 24/28] pc-bios/s390-ccw: Handle true secure IPL mode
- Edited documentation
- Used panic instead of IPL_assert() in zipl_secure_handle()

[PATCH v6 25/28] pc-bios/s390-ccw: Handle secure boot with multiple boot devices
- Used a stack variable for QemuIplParameters instead of a malloc in check_secure_boot_support()

Changelog v5->v6

Add boot-certs to s390-ccw-virtio machine type option
- Renamed struct BootCertPath to BootCertificate
- Defined DummyBootCertificates struct for QMP to use BootCertificateList internally

crypto/x509-utils
- Used gnutls_x509_crt_export2() in qcrypto_x509_convert_cert_der()
- Allocated buffers with g_new for results in qcrypto_x509_convert_cert_der() and qcrypto_pkcs7_convert_sig_pem()
- Added check for qcrypto_to_gnutls_hash_alg_map bounds in qcrypto_x509_get_cert_key_id()
- Added qcrypto_x509_is_ecc_curve_p521() function to determine if an ECC public key algorithm uses P521 curve
- Fixed typo

hw/s390x/ipl: Create certificate store
- Made any configuration errors fatal when loading certificates into the cert store
- Removed key_id_size and hash_size from S390IPLCertificate and defined them as constants
- Do not reinitialize the cert store if it already exists
- Handled memory cleanup

s390x/diag: Implement DIAG 320 subcode 1
- Added QEMU_BUILD_BUG_MSG

s390x/diag: Implement DIAG 320 subcode 2
- Refactored build_vce_header() and created a new function for getting key type
- Added QEMU_BUILD_BUG_MSG

s390x/diag: Implement DIAG 508 subcode 1 for signature verification
- Updated Diag508SigVerifBlock

hw/s390x/ipl: Add IPIB flags to IPL Parameter Block
- Override IPLB length only when DIAG308_IPIB_FLAGS_IPLIR flag is set
- Dropped hw/s390x/ipl: Set iplb->len to maximum length of IPL Parameter Block patch

pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Added validation for VCB and VCE before retrieving information in request_certificate()
- Replaced uint64_t *cert with uint8_t *cert in zipl_run_secure()

Changelog v4->v5

- Segmented documentation by introducing them alongside the patches that add the relevant functionality
- Removed hash-type restriction from S390IPLCertificateStore

Add boot-certs to s390-ccw-virtio machine type option
- Added boot-certs property to the s390-ccw-virtio machine type

    - Changed to use an array property for passing certificate instead
      of colo-delimited strings.
    e.g. boot-certs.0.path=/path/to/dir,
         boot-certs.1.path=/to/other/dir,
         boot-certs.2.path=/some/...

crypto/x509-utils
- Refactored fallback handling into a separated commit
- Removed QCryptoKeyidFlags and qcrypto_x509_get_keyid_len() function
- Removed qcrypto_x509_get_cert_version() and qcrypto_x509_get_signature_algorithm()
- Passed QCryptoHashAlgo to qcrypto_x509_get_cert_key_id() instead of QCryptoKeyidFlags
- Improved memory cleanup

hw/s390x/ipl: Create certificate store
- Fixed error handling and memory management
- Added condition to only accept files with ".pem" extension

s390x: Guest support for Certificate Store Facility (CS)
- Renamed "S390_FEAT_DIAG_320" to "S390_FEAT_CERT_STORE"
- Merged this patch with s390x/diag: Introduce DIAG 320 for certificate store facility patch

s390x/diag: Introduce DIAG 320 for certificate store facility
- Added bit zero to indicate subcode 0 is supported
- Set response code to 0x0102 when the subcode is not supported
- Added check to ensure subcode fits within one byte

s390x/diag: Implement DIAG 320 subcode 1
- Refactored and moved implementation to a helper function
- Added check to ensure VCSSB length is set to a minimum of 128 bytes from the userspace
- Removed max_vce_len field from the VCSSB data structure

s390x/diag: Implement DIAG 320 subcode 2
- Refactored and split functions for extracting certificate information
- Set VCE length to 72 if certificate is invalid
- Returned VCE even if the certificate is invalid

pc-bios/s390-ccw: Refactor zipl_run()
- Refactor zipl_run_normal() to reduce duplicate code

pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Moved secure-boot related functions into secure-ipl.c/h files
- Rename zipl_handle_sig_entry() to zipl_load_signature()
- Refactored zipl_run_secure() to use switch cases for different entry types instead of a while loop
- Renamed ZiplBootMode enumerations with "ZIPL_BOOT_MODE" prefix
- Added meaningful file header to secure-ipl.c
- Renamed zipl_secure_print() to zipl_secure_handle()

Changelog v3->v4:

cyrpto/x590-utils
- Updated patch descriptions to summarize what each patch introduces.
- Restricted accepted certificate format on the QEMU command line to PEM only.
- Added internal conversion routines to handle PEM-to-DER and
DER-to-PEM as needed.
- Renamed crypto functions using the qcrypto_x509_ prefix.
- Replaced QAPI enums with plain C enums.
- Improved GNUTLS error propagation throughout the crypto API.
- Standardized error returns to -1 (instead of using errno values) for consistency.
- Removed unused helpers: qcrypto_check_x509_cert_fmt() and qcrypto_get_x509_hash_len().
- Added bounds checking before converting GNUTLS enums to internal crypto enums.
- Modified qcrypto_get_x509_cert_key_id() to dynamically allocate the result.
- Fixed a typo in the crypto API documentation.

hw/s390x/ipl: Create certificate store
- Removed max_size check when loading certificate.
- Removed check_path_type() and use the stat() & S_ISXXX checks inline where needed.
- Initialized all g_autofree variables.
- Refactored get_cert_paths()
- Used g_auto(GStrv) and g_autoptr(GPtrArray) for automatic cleanup.
- Renamed misleading variables and dropped unnecessary intermediates.
- Replaced check_path_type() with stat(), and treated failures as fatal.
- Treated empty path components as fatal configuration errors.
- Used GError with g_dir_open() and handled errors properly.
- Removed redundant casts and manual cleanup.
- Treated providing 65 or more certificates as a fatal error.
- Modified S390IPLCertificate
- Changed raw from char * to uint8_t * for API consistency.
- Added cert_der field to calculate certificate data buffer size for
DIAG 320 and format conversion.

s390x/diag
- Handled error propagation from crypto API correctly.
- Added g_autofree to variables to ensure proper memory cleanup.
- Initialized all g_autofree variables.

pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Allocated certificate buffer based on calculated size instead of static MAX_CERT_SIZE.

pc-bios/s390-ccw: Add additional security checks for secure boot
- Refactored to improve readability.
- Handled SCLAB Single Component/No Unsigned Component flags.

docs: Add secure IPL documentation
- Updated documentation.
- Illustrated with gnutls ‘certtool’ instead of ‘openssl’ for consistency with other certificate creation docs.

- Updated cover letter with corresponding changes.

Changelog v2->v3:

- Fixed typos in patches
- Edited and corrected patch description
- Enabled secure IPL feature in TCG
- Split crypto subsystem changes from s390x subsystem changes
- Added API documentation for each helper function
- Removed qcrypto_get_x509_cert_fmt()
- Reworked qcrypto_check_x509_cert_fmt() to return 0 on success and
negative error code on errors
- Rephrased error messages when GNUTLS is not enabled
- Changed dev cycle reference from 9.2 to 10.1

hw/s390x/ipl: Create certificate store
- Passed *cert_buf to g_file_get_contents() directly in cert2buf()
- Returned NULL for early returns
- Added check to only allow maximum of 64 certificates in the certificate store

s390x: Guest support for Certificate Store Facility (CS)
- Renamed “diag320” to “cstore”

s390x/diag: Implement DIAG 320 subcode 1
- Removed QEMU_PACKED from VCStorageSizeBlock
- Removed unnecessary error check from subcode 1 implementation

s390x/diag: Implement DIAG 320 subcode 2
- Removed QEMU_PACKED from VCBlock and VCEngtry
- Reworked diag_320_is_cert_valid() to return 0 on success and negative error code on errors
- Set *key_id_data and *hash_data to NULL after g_free()
- Moved DIAG_320_SUBC_STORE_VC case block implementation to a separate function

s390x/diag: Implement DIAG 508 subcode 1 for signature verification
- Added a reserved field to Diag508CertificateStoreInfo
- Removed QEMU_PACKED from Diag508CertificateStoreInfo and Diag508SignatureVerificationBlock
- Applied g_autofree to svb, svb_comp and svb_sig varaibles
- Moved DIAG_508_SUBC_SIG_VERIF case block implementation to a separate function

pc-bios/s390-ccw: Refactor zipl_load_segment function
- Removed casting when calculating comp_len

pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode
- Used malloc() to allocate certificate buffer instead of statically allocating
- Reworked zipl_secure_print()

s390x: Guest support for Secure-IPL Code Loading Attributes Facility (SCLAF)
- Added check to make sure SIPL is enabled when SCLAF is enabled

docs: Add secure IPL documentation
- Split document into two parts:
- docs/specs/s390x-secure-ipl.rst (developer reference)
- docs/system/s390x/secure-ipl.rst (user guide)

Changelog v1->v2:

- Fixed typos in patches
- Edited cover letter
- Added secure IPL documentation

QEMU Command-Line Interface:
- Moved boot-certificates under the machine-type option for s390x-virtio-ccw
- Moved secure-boot under the machine-type option for s390x-virtio-ccw

hw/s390x/ipl: Create Certificate Store
- Defined internal GNUTLS-related APIs
- Added check to only accept certificates using SHA-256 hashing
- Recalculated data_buf_size to ensure word alignment
- Cleaned up memory allocation
- Refactored functions for clarity

s390x: Guest Support for Certificate Store Facility (CS)
- Updated patch description to clarify:
- Why Secure IPL is not available with Secure Execution
- Why this feature requires S390_FEAT_EXTENDED_LENGTH_SCCB
-Restricted features to z16 due to additional layers requiring z16

s390x/diag: Implement DIAG 320 Subcode 1
- Renamed VerificationCertificate prefix to VC
- Byte-swap written values for endianness correctness

s390x/diag: Implement DIAG 320 Subcode 2
- Edited commit message for clarity
- Defined internal GNUTLS-related APIs
- Renamed data structure variables
- Ensured length fields in VCE are word-aligned
- Handled the VC index 0 case
- General refactoring

s390x/diag: Implement DIAG 508 Subcode 2 for Signature Verification
- Defined subcode from 2 to 1
- Removed unused error codes
- Defined internal GNUTLS-related APIs
- Byte-swap read values

hw/s390x/ipl: Add IPIB Flags to IPL Parameter Block
- Moved DIAG308 flags to a new header file

s390x: Guest Support for Secure-IPL Facility
- Renamed SCLP variable from cbl to fac_ipl

pc-bios/s390-ccw: Add Signature Verification for Secure Boot (Audit Mode)
- Moved Secure IPL-related functions to pc-bios/s390-ccw/secure-ip.c|h
- Refactored code for clarity

Collin L. Walling (2):
s390x/diag: Introduce DIAG 508 for secure IPL operations s390x/diag: Implement DIAG 508 subcode 1 for signature verification

Zhuoying Cai (30):
Add boot-certs to s390-ccw-virtio machine type option crypto/x509-utils: Refactor with GNUTLS fallback crypto/x509-utils: Add helper functions for certificate store hw/s390x/ipl: Create certificate store
s390x/diag: Introduce DIAG 320 for Certificate Store Facility s390x/diag: Refactor address validation check from diag308_parm_check s390x/diag: Implement DIAG 320 subcode 1 crypto/x509-utils: Add helper functions for DIAG 320 subcode 2 s390x/diag: Implement DIAG 320 subcode 2
hw/s390x: Define finite size for single entry VCEntry crypto/x509-utils: Add helper functions for DIAG 508 subcode 1 s390x/ipl: Introduce IPL Information Report Block (IIRB) pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers hw/s390x/ipl: Add IPIB flags to IPL Parameter Block
s390x: Guest support for Secure-IPL Facility pc-bios/s390-ccw: Refactor zipl_run()
pc-bios/s390-ccw: Rework zipl_load_segment function pc-bios/s390-ccw: Introduce ZiplBootMode enum for IPL mode selection pc-bios/s390-ccw: Add signature verification for secure IPL in audit
mode
pc-bios/s390-ccw: Add signed component address overlap checks
s390x: Guest support for Secure-IPL Code Loading Attributes Facility

    (SCLAF)

pc-bios/s390-ccw: Add additional security checks for secure boot Add secure-boot to s390-ccw-virtio machine type option hw/s390x/ipl: Set IPIB flags for secure IPL pc-bios/s390-ccw: Handle true secure IPL mode hw/s390x/ipl: Handle secure boot with multiple boot devices hw/s390x/ipl: Handle secure boot without specifying a boot device tests/functional/s390x: Add secure IPL functional test docs/specs: Add secure IPL documentation docs/system/s390x: Add secure IPL documentation

 crypto/meson.build                        |   2 +-
 crypto/x509-utils.c                       | 409 ++++++++++++++
 docs/specs/index.rst                      |   1 +
 docs/specs/s390x-secure-ipl.rst           | 193 +++++++
 docs/system/s390x/secure-ipl.rst          | 181 +++++++
 docs/system/target-s390x.rst              |   1 +
 hw/s390x/cert-store.c                     | 232 ++++++++
 hw/s390x/cert-store.h                     |  38 ++
 hw/s390x/ipl.c                            |  87 +++
 hw/s390x/ipl.h                            |  27 +-
 hw/s390x/meson.build                      |   1 +
 hw/s390x/s390-virtio-ccw.c                |  52 ++
 hw/s390x/sclp.c                           |   2 +
 include/crypto/x509-utils.h               | 113 ++++
 include/hw/s390x/ipl/diag308.h            |  34 ++
 include/hw/s390x/ipl/diag320.h            | 109 ++++
 include/hw/s390x/ipl/diag508.h            |  45 ++
 include/hw/s390x/ipl/qipl.h               | 108 +++-
 include/hw/s390x/s390-virtio-ccw.h        |   3 +
 include/hw/s390x/sclp.h                   |   4 +-
 pc-bios/s390-ccw/Makefile                 |   2 +-
 pc-bios/s390-ccw/bootmap.c                | 101 +++-
 pc-bios/s390-ccw/bootmap.h                |  11 +
 pc-bios/s390-ccw/iplb.h                   |   5 +-
 pc-bios/s390-ccw/jump2ipl.c               |   6 +-
 pc-bios/s390-ccw/main.c                   |  46 +-
 pc-bios/s390-ccw/netmain.c                |   8 +-
 pc-bios/s390-ccw/s390-ccw.h               |  31 ++
 pc-bios/s390-ccw/sclp.c                   |  27 +
 pc-bios/s390-ccw/sclp.h                   |   7 +
 pc-bios/s390-ccw/secure-ipl.c             | 615 ++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h             | 193 +++++++
 qapi/machine-s390x.json                   |  23 +
 qapi/pragma.json                          |   1 +
 qemu-options.hx                           |  10 +-
 target/s390x/cpu_features.c               |   7 +
 target/s390x/cpu_features.h               |   1 +
 target/s390x/cpu_features_def.h.inc       |   5 +
 target/s390x/cpu_models.c                 |   7 +
 target/s390x/diag.c                       | 588 ++++++++++++++++++++-
 target/s390x/gen-features.c               |   7 +
 target/s390x/kvm/kvm.c                    |  34 ++
 target/s390x/s390x-internal.h             |   4 +
 target/s390x/tcg/misc_helper.c            |  14 +
 tests/functional/s390x/meson.build        |   2 +
 tests/functional/s390x/test_secure_ipl.py | 148 ++++++
 46 files changed, 3466 insertions(+), 79 deletions(-)
 create mode 100644 docs/specs/s390x-secure-ipl.rst
 create mode 100644 docs/system/s390x/secure-ipl.rst
 create mode 100644 hw/s390x/cert-store.c
 create mode 100644 hw/s390x/cert-store.h
 create mode 100644 include/hw/s390x/ipl/diag308.h
 create mode 100644 include/hw/s390x/ipl/diag320.h
 create mode 100644 include/hw/s390x/ipl/diag508.h
 create mode 100644 pc-bios/s390-ccw/secure-ipl.c
 create mode 100644 pc-bios/s390-ccw/secure-ipl.h
 create mode 100755 tests/functional/s390x/test_secure_ipl.py
Signature · 1 line
2.54.0
#1 lore raw

PATCH v11 1/32 Add boot-certs to s390-ccw-virtio machine type option

Introduce a new boot-certs machine type option for the s390-ccw-virtio machine. This allows users to specify one or more certificate file paths or directories to be used during secure boot.

Each entry is specified using the syntax:
boot-certs.<index>.path=/path/to/cert.pem

Multiple paths can be specify using array properties:

	boot-certs.0.path=/path/to/cert.pem,
	boot-certs.1.path=/path/to/cert-dir,
	boot-certs.2.path=/path/to/another-dir...
---
 docs/system/s390x/secure-ipl.rst   | 20 ++++++++++++++++++++
 docs/system/target-s390x.rst       |  1 +
 hw/s390x/s390-virtio-ccw.c         | 30 ++++++++++++++++++++++++++++++
 include/hw/s390x/s390-virtio-ccw.h |  2 ++
 qapi/machine-s390x.json            | 23 +++++++++++++++++++++++
 qapi/pragma.json                   |  1 +
 qemu-options.hx                    |  6 +++++-
 7 files changed, 82 insertions(+), 1 deletion(-)
 create mode 100644 docs/system/s390x/secure-ipl.rst
docs/system/s390x/secure-ipl.rst new file +20 -0
new file mode 100644
index 0000000000..88df52ce2f
@@ -0,0 +1,20 @@
+.. SPDX-License-Identifier: GPL-2.0-or-later
+
+Secure IPL Command Line Options
+-------------------------------
+
+The s390-ccw-virtio machine type supports secure IPL. These parameters allow
+users to provide certificates and enable secure IPL directly via the command
+line.
+
+Providing Certificates
+^^^^^^^^^^^^^^^^^^^^^^
+
+The certificate store can be populated by supplying a list of X.509 certificate
+file paths or directories containing certificate files on the command-line:
+
+Note: certificate files must have a .pem extension.
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
docs/system/target-s390x.rst +1 -0
index 94c981e732..8938a13d10 100644
@@ -35,3 +35,4 @@ Architectural features
    s390x/bootdevices
    s390x/protvirt
    s390x/cpu-topology
+   s390x/secure-ipl
hw/s390x/s390-virtio-ccw.c +30 -0
index 4d35f9b10b..39adb69cfd 100644
@@ -44,6 +44,7 @@
 #include "target/s390x/kvm/pv.h"
 #include "migration/blocker.h"
 #include "qapi/visitor.h"
+#include "qapi/qapi-visit-machine-s390x.h"
 #include "hw/s390x/cpu-topology.h"
 #include "kvm/kvm_s390x.h"
 #include "hw/virtio/virtio-md-pci.h"
@@ -788,6 +789,30 @@ static void machine_set_loadparm(Object *obj, Visitor *v,
     g_free(val);
 }
 
+static void machine_get_boot_certs(Object *obj, Visitor *v,
+                                   const char *name, void *opaque,
+                                   Error **errp)
+{
+    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+    BootCertificatesList **certs = &ms->boot_certs;
+
+    visit_type_BootCertificatesList(v, name, certs, errp);
+}
+
+static void machine_set_boot_certs(Object *obj, Visitor *v, const char *name,
+                                   void *opaque, Error **errp)
+{
+    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+    BootCertificatesList *cert_list = NULL;
+
+    visit_type_BootCertificatesList(v, name, &cert_list, errp);
+    if (!cert_list) {
+        return;
+    }
+
+    ms->boot_certs = cert_list;
+}
+
  /*
   * S390x-specific global compatibility properties.
   *
@@ -856,6 +881,11 @@ static void ccw_machine_class_init(ObjectClass *oc, const void *data)
             "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
             " to upper case) to pass to machine loader, boot manager,"
             " and guest kernel");
+
+    object_class_property_add(oc, "boot-certs", "BootCertificatesList",
+                              machine_get_boot_certs, machine_set_boot_certs, NULL, NULL);
+    object_class_property_set_description(oc, "boot-certs",
+            "provide paths to a directory and/or a certificate file for secure boot");
 }
 
 static inline void s390_machine_initfn(Object *obj)
include/hw/s390x/s390-virtio-ccw.h +2 -0
index f1f06119d6..5ad1ea2f24 100644
@@ -14,6 +14,7 @@
 #include "hw/core/boards.h"
 #include "qom/object.h"
 #include "hw/s390x/sclp.h"
+#include "qapi/qapi-types-machine-s390x.h"
 
 #define TYPE_S390_CCW_MACHINE               "s390-ccw-machine"
 
@@ -31,6 +32,7 @@ struct S390CcwMachineState {
     uint8_t loadparm[8];
     uint64_t memory_limit;
     uint64_t max_pagesize;
+    BootCertificatesList *boot_certs;
 
     SCLPDevice *sclp;
 };
qapi/machine-s390x.json +23 -0
index ea430e1b88..bbe3646e91 100644
@@ -140,3 +140,26 @@
 { 'event': 'SCLP_CPI_INFO_AVAILABLE',
   'features': [ 'unstable' ]
 }
+
+##
+# @BootCertificates:
+#
+# Boot certificates for secure IPL.
+#
+# @path: path to an X.509 certificate file or a directory containing
+#      certificate files.
+#
+# Since: 11.1
+##
+{ 'struct': 'BootCertificates',
+  'data': {'path': 'str'} }
+
+##
+# @DummyBootCertificates:
+#
+# Not used by QMP; hack to let us use BootCertificatesList internally.
+#
+# Since: 11.1
+##
+{ 'struct': 'DummyBootCertificates',
+  'data': {'unused-boot-certs': ['BootCertificates'] } }
qapi/pragma.json +1 -0
index 24aebbe8f5..342cedc42e 100644
@@ -49,6 +49,7 @@
         'DisplayProtocol',
         'DriveBackupWrapper',
         'DummyBlockCoreForceArrays',
+        'DummyBootCertificates',
         'DummyForceArrays',
         'DummyVirtioForceArrays',
         'HotKeyMod',
qemu-options.hx +5 -1
index 83a3aa9f0b..7f97a0d07e 100644
@@ -45,7 +45,8 @@ DEF("machine", HAS_ARG, QEMU_OPTION_machine, \
     "                memory-backend='backend-id' specifies explicitly provided backend for main RAM (default=none)\n"
     "                cxl-fmw.0.targets.0=firsttarget,cxl-fmw.0.targets.1=secondtarget,cxl-fmw.0.size=size[,cxl-fmw.0.interleave-granularity=granularity]\n"
     "                sgx-epc.0.memdev=memid,sgx-epc.0.node=numaid\n"
-    "                smp-cache.0.cache=cachename,smp-cache.0.topology=topologylevel\n",
+    "                smp-cache.0.cache=cachename,smp-cache.0.topology=topologylevel\n"
+    "                boot-certs.0.path=/path/directory,boot-certs.1.path=/path/file provides paths to a directory and/or a certificate file\n",
     QEMU_ARCH_ALL)
 SRST
 ``-machine [type=]name[,prop=value[,...]]``
@@ -209,6 +210,9 @@ SRST
         ::
 
             -machine smp-cache.0.cache=l1d,smp-cache.0.topology=core,smp-cache.1.cache=l1i,smp-cache.1.topology=core
+
+    ``boot-certs.0.path=/path/directory,boot-certs.1.path=/path/file``
+        Provide paths to a directory and/or a certificate file on the host [s390x only].
 ERST
 
 DEF("M", HAS_ARG, QEMU_OPTION_M,
Signature · 1 line
2.54.0
#2 lore raw

PATCH v11 2/32 crypto/x509-utils: Refactor with GNUTLS fallback

In reply to Zhuoying Cai

Always compile x509-utils.c and add a fallback when GNUTLS is unavailable.

These functions will be needed in the s390x code regardless of whether GNUTLS is available.

---
 crypto/meson.build  |  2 +-
 crypto/x509-utils.c | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)
crypto/meson.build +1 -1
index b51597a879..fda85543de 100644
@@ -22,12 +22,12 @@ crypto_ss.add(files(
   'tlscredsx509.c',
   'tlssession.c',
   'rsakey.c',
+  'x509-utils.c',
 ))
 
 if gnutls.found()
   crypto_ss.add(files(
     'tlscredsbox.c',
-    'x509-utils.c',
   ))
 endif
 
crypto/x509-utils.c +16 -0
index 39bb6d4d8c..6176a88653 100644
@@ -11,6 +11,8 @@
 #include "qemu/osdep.h"
 #include "qapi/error.h"
 #include "crypto/x509-utils.h"
+
+#ifdef CONFIG_GNUTLS
 #include <gnutls/gnutls.h>
 #include <gnutls/crypto.h>
 #include <gnutls/x509.h>
@@ -78,3 +80,17 @@ int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
     gnutls_x509_crt_deinit(crt);
     return ret;
 }
+
+#else /* ! CONFIG_GNUTLS */
+
+int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
+                                      QCryptoHashAlgo hash,
+                                      uint8_t *result,
+                                      size_t *resultlen,
+                                      Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to get fingerprint");
+    return -1;
+}
+
+#endif /* ! CONFIG_GNUTLS */
Signature · 1 line
2.54.0
#3 lore raw

PATCH v11 3/32 crypto/x509-utils: Add helper functions for certificate store

In reply to Zhuoying Cai

Introduce new helper functions for x509 certificate, which will be used by the certificate store:

qcrypto_x509_convert_cert_der() - converts a certificate from PEM to DER format

These functions provide support for certificate format conversion.

---
 crypto/x509-utils.c         | 49 +++++++++++++++++++++++++++++++++++++
 include/crypto/x509-utils.h | 21 ++++++++++++++++
 2 files changed, 70 insertions(+)
crypto/x509-utils.c +49 -0
index 6176a88653..68cf008938 100644
@@ -81,6 +81,46 @@ int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
     return ret;
 }
 
+int qcrypto_x509_convert_cert_der(uint8_t *cert, size_t size,
+                                  uint8_t **result, size_t *resultlen,
+                                  Error **errp)
+{
+    int ret = -1;
+    int rc;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+    gnutls_datum_t datum_der = {.data = NULL, .size = 0};
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_x509_crt_export2(crt, GNUTLS_X509_FMT_DER, &datum_der);
+    if (rc != 0) {
+        error_setg(errp, "Failed to convert certificate to DER format: %s",
+                   gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    *resultlen = datum_der.size;
+    *result = g_memdup2(datum_der.data, datum_der.size);
+
+    ret = 0;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    g_free(datum_der.data);
+    return ret;
+}
+
 #else /* ! CONFIG_GNUTLS */
 
 int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
@@ -93,4 +133,13 @@ int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
     return -1;
 }
 
+int qcrypto_x509_convert_cert_der(uint8_t *cert, size_t size,
+                                  uint8_t **result,
+                                  size_t *resultlen,
+                                  Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to export X.509 certificate");
+    return -1;
+}
+
 #endif /* ! CONFIG_GNUTLS */
include/crypto/x509-utils.h +21 -0
index 1e99661a71..91ae79fb03 100644
@@ -19,4 +19,25 @@ int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
                                       size_t *resultlen,
                                       Error **errp);
 
+/**
+ * qcrypto_x509_convert_cert_der
+ * @cert: pointer to the raw certificate data in PEM format
+ * @size: size of the certificate
+ * @result: output location for the allocated buffer for the certificate
+ *          in DER format
+ *          (the function allocates memory which must be freed by the caller)
+ * @resultlen: pointer to the size of the buffer (will be updated with the
+ *             actual size of the DER-encoded certificate)
+ * @errp: error pointer
+ *
+ * Convert the given @cert from PEM to DER format.
+ *
+ * Returns: 0 on success,
+ *         -1 on error.
+ */
+int qcrypto_x509_convert_cert_der(uint8_t *cert, size_t size,
+                                  uint8_t **result,
+                                  size_t *resultlen,
+                                  Error **errp);
+
 #endif
Signature · 1 line
2.54.0
#4 lore raw

PATCH v11 4/32 hw/s390x/ipl: Create certificate store

In reply to Zhuoying Cai

Create a certificate store for boot certificates used for secure IPL.

Load certificates from the boot-certs parameter of s390-ccw-virtio machine type option into the cert store.

Currently, only X.509 certificates in PEM format are supported, as the QEMU command line accepts certificates in PEM format only.

---
 docs/specs/index.rst            |   1 +
 docs/specs/s390x-secure-ipl.rst |  16 +++
 hw/s390x/cert-store.c           | 221 ++++++++++++++++++++++++++++++++
 hw/s390x/cert-store.h           |  39 ++++++
 hw/s390x/ipl.c                  |  10 ++
 hw/s390x/ipl.h                  |   3 +
 hw/s390x/meson.build            |   1 +
 include/hw/s390x/ipl/qipl.h     |   2 +
 8 files changed, 293 insertions(+)
 create mode 100644 docs/specs/s390x-secure-ipl.rst
 create mode 100644 hw/s390x/cert-store.c
 create mode 100644 hw/s390x/cert-store.h
docs/specs/index.rst +1 -0
index b7909a108a..76d439782c 100644
@@ -40,3 +40,4 @@ guest hardware that is specific to QEMU.
    riscv-aia
    aspeed-intc
    iommu-testdev
+   s390x-secure-ipl
docs/specs/s390x-secure-ipl.rst new file +16 -0
new file mode 100644
index 0000000000..1cdf19783f
@@ -0,0 +1,16 @@
+.. SPDX-License-Identifier: GPL-2.0-or-later
+
+s390 Certificate Store and Functions
+------------------------------------
+
+s390 Certificate Store
+^^^^^^^^^^^^^^^^^^^^^^
+
+A certificate store is implemented for s390-ccw guests to retain within
+memory all certificates provided by the user via the command-line, which
+are expected to be stored somewhere on the host's file system. The store
+will keep track of the number of certificates, their respective size,
+and a summation of the sizes.
+
+Note: A maximum of 64 certificates are allowed to be stored in the certificate
+store.
hw/s390x/cert-store.c new file +221 -0

221 lines not on this page · raw message

hw/s390x/cert-store.h new file +39 -0
new file mode 100644
index 0000000000..7fc9503cb9
@@ -0,0 +1,39 @@
+/*
+ * S390 certificate store
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef HW_S390_CERT_STORE_H
+#define HW_S390_CERT_STORE_H
+
+#include "hw/s390x/ipl/qipl.h"
+#include "crypto/x509-utils.h"
+
+#define CERT_NAME_MAX_LEN  64
+
+#define CERT_KEY_ID_LEN    QCRYPTO_HASH_DIGEST_LEN_SHA256
+#define CERT_HASH_LEN      QCRYPTO_HASH_DIGEST_LEN_SHA256
+
+struct S390IPLCertificate {
+    uint8_t name[CERT_NAME_MAX_LEN];
+    size_t  size;
+    size_t  der_size;
+    uint8_t *raw;
+};
+typedef struct S390IPLCertificate S390IPLCertificate;
+
+struct S390IPLCertificateStore {
+    uint16_t count;
+    size_t   largest_cert_size;
+    size_t   total_bytes;
+    S390IPLCertificate certs[MAX_CERTIFICATES];
+};
+typedef struct S390IPLCertificateStore S390IPLCertificateStore;
+
+void s390_ipl_create_cert_store(S390IPLCertificateStore *cert_store);
+
+#endif
hw/s390x/ipl.c +10 -0
index 1babcd2b7d..fbef46aee5 100644
@@ -38,6 +38,7 @@
 #include "qemu/option.h"
 #include "qemu/ctype.h"
 #include "standard-headers/linux/virtio_ids.h"
+#include "cert-store.h"
 
 #define KERN_IMAGE_START                0x010000UL
 #define LINUX_MAGIC_ADDR                0x010008UL
@@ -453,6 +454,13 @@ void s390_ipl_convert_loadparm(char *ascii_lp, uint8_t *ebcdic_lp)
     }
 }
 
+S390IPLCertificateStore *s390_ipl_get_certificate_store(void)
+{
+    S390IPLState *ipl = get_ipl_device();
+
+    return &ipl->cert_store;
+}
+
 static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
 {
     CcwDevice *ccw_dev = NULL;
@@ -771,6 +779,8 @@ void s390_ipl_prepare_cpu(S390CPU *cpu)
     cpu->env.psw.addr = ipl->start_addr;
     cpu->env.psw.mask = IPL_PSW_MASK;
 
+    s390_ipl_create_cert_store(&ipl->cert_store);
+
     if (!ipl->kernel || ipl->iplb_valid) {
         cpu->env.psw.addr = ipl->bios_start_addr;
         if (!ipl->iplb_valid) {
hw/s390x/ipl.h +3 -0
index fac30763df..f5a49a4431 100644
@@ -13,6 +13,7 @@
 #ifndef HW_S390_IPL_H
 #define HW_S390_IPL_H
 
+#include "cert-store.h"
 #include "target/s390x/cpu.h"
 #include "exec/target_page.h"
 #include "system/address-spaces.h"
@@ -35,6 +36,7 @@ int s390_ipl_pv_unpack(struct S390PVResponse *pv_resp);
 void s390_ipl_prepare_cpu(S390CPU *cpu);
 IplParameterBlock *s390_ipl_get_iplb(void);
 IplParameterBlock *s390_ipl_get_iplb_pv(void);
+S390IPLCertificateStore *s390_ipl_get_certificate_store(void);
 
 enum s390_reset {
     /* default is a reset not triggered by a CPU e.g. issued by QMP */
@@ -63,6 +65,7 @@ struct S390IPLState {
     IplParameterBlock iplb;
     IplParameterBlock iplb_pv;
     QemuIplParameters qipl;
+    S390IPLCertificateStore cert_store;
     uint64_t start_addr;
     uint64_t compat_start_addr;
     uint64_t bios_start_addr;
hw/s390x/meson.build +1 -0
index 57cc2a6be3..6b39ad012f 100644
@@ -17,6 +17,7 @@ s390x_ss.add(files(
   'sclpcpu.c',
   'sclpquiesce.c',
   'tod.c',
+  'cert-store.c',
 ))
 s390x_ss.add(when: 'CONFIG_KVM', if_true: files(
   'tod-kvm.c',
include/hw/s390x/ipl/qipl.h +2 -0
index 8d3c83a80b..ed1a91182a 100644
@@ -31,6 +31,8 @@ typedef enum S390IplType S390IplType;
 
 #define QEMU_DEFAULT_IPL S390_IPL_TYPE_CCW
 
+#define MAX_CERTIFICATES  64
+
 /*
  * The QEMU IPL Parameters will be stored at absolute address
  * 204 (0xcc) which means it is 32-bit word aligned but not
Signature · 1 line
2.54.0
#5 lore raw

Re: [PATCH v11 04/32] hw/s390x/ipl: Create certificate store

Quoted 7 lines · Zhuoying Cai

Create a certificate store for boot certificates used for secure IPL.

Load certificates from the boot-certs parameter of s390-ccw-virtio machine type option into the cert store.

Currently, only X.509 certificates in PEM format are supported, as the QEMU command line accepts certificates in PEM format only.

Let's add more context here:

"The raw Base64 data is stored, as well as the certificate's size. The binary (DER) size is stored as well, which may later be utilized for secure boot (signature verification)."

Quoted 35 lines
---
 docs/specs/index.rst            |   1 +
 docs/specs/s390x-secure-ipl.rst |  16 +++
 hw/s390x/cert-store.c           | 221 ++++++++++++++++++++++++++++++++
 hw/s390x/cert-store.h           |  39 ++++++
 hw/s390x/ipl.c                  |  10 ++
 hw/s390x/ipl.h                  |   3 +
 hw/s390x/meson.build            |   1 +
 include/hw/s390x/ipl/qipl.h     |   2 +
 8 files changed, 293 insertions(+)
 create mode 100644 docs/specs/s390x-secure-ipl.rst
 create mode 100644 hw/s390x/cert-store.c
 create mode 100644 hw/s390x/cert-store.h
docs/specs/index.rst +1 -0
index b7909a108a..76d439782c 100644
@@ -40,3 +40,4 @@ guest hardware that is specific to QEMU.
    riscv-aia
    aspeed-intc
    iommu-testdev
+   s390x-secure-ipl
docs/specs/s390x-secure-ipl.rst new file +3 -0
new file mode 100644
index 0000000000..1cdf19783f
@@ -0,0 +1,16 @@
+.. SPDX-License-Identifier: GPL-2.0-or-later
+
+s390 Certificate Store and Functions

docs/specs/s390x-secure-ipl.rst line 13

Quoted 10 lines
docs/specs/s390x-secure-ipl.rst new file +10 -0
+------------------------------------
+
+s390 Certificate Store
+^^^^^^^^^^^^^^^^^^^^^^
+
+A certificate store is implemented for s390-ccw guests to retain within
+memory all certificates provided by the user via the command-line, which
+are expected to be stored somewhere on the host's file system. The store
+will keep track of the number of certificates, their respective size,
+and a summation of the sizes.

Add:

"Each certificate is stroed in an S390IPLCertificate struct, which has a name (converted to EBCDIC), size fields of PEM and DER data, and the raw PEM Base64 data."

Quoted 29 lines
docs/specs/s390x-secure-ipl.rst new file +3 -0
+
+Note: A maximum of 64 certificates are allowed to be stored in the certificate
+store.
hw/s390x/cert-store.c new file +20 -0
new file mode 100644
index 0000000000..a4f15627e9
@@ -0,0 +1,221 @@
+/*
+ * S390 certificate store implementation
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "qemu/osdep.h"
+#include "cert-store.h"
+#include "qapi/error.h"
+#include "qemu/error-report.h"
+#include "qemu/option.h"
+#include "qemu/config-file.h"
+#include "hw/s390x/ebcdic.h"
+#include "hw/s390x/s390-virtio-ccw.h"
+#include "qemu/cutils.h"
+#include "crypto/x509-utils.h"
+#include "qapi/qapi-types-machine-s390x.h"

hw/s390x/cert-store.c line 30

Quoted 10 lines
hw/s390x/cert-store.c new file +10 -0
+
+static BootCertificatesList *s390_get_boot_certs(void)
+{
+    return S390_CCW_MACHINE(qdev_get_machine())->boot_certs;
+}
+
+static S390IPLCertificate *init_cert(char *path, Error **errp)
+{
+    int rc;
+    char *buf;

What about g_autofree for buf...

Quoted 11 lines
hw/s390x/cert-store.c new file +11 -0
+    size_t size;
+    size_t der_len;
+    char name[CERT_NAME_MAX_LEN];
+    g_autofree gchar *filename = NULL;
+    S390IPLCertificate *cert = NULL;
+    g_autofree uint8_t *cert_der = NULL;
+    Error *local_err = NULL;
+
+    filename = g_path_get_basename(path);
+
+    if (!g_file_get_contents(path, &buf, &size, NULL)) {

hw/s390x/cert-store.c line 51

Quoted 10 lines
hw/s390x/cert-store.c new file +10 -0
+        error_setg(errp, "Failed to load certificate: %s", path);
+        return NULL;
+    }
+
+    rc = qcrypto_x509_convert_cert_der((uint8_t *)buf, size,
+                                       &cert_der, &der_len, &local_err);
+    if (rc != 0) {
+        error_propagate_prepend(errp, local_err,
+                                "Failed to initialize certificate: %s: ", path);
+        g_free(buf);

...this could go away...

hw/s390x/cert-store.c line 64

Quoted 13 lines
hw/s390x/cert-store.c new file +13 -0
+        return NULL;
+    }
+
+    cert = g_new0(S390IPLCertificate, 1);
+    cert->size = size;
+    /*
+     * Store DER length only - reused for size calculation.
+     * cert_der is discarded because DER certificate data will be used once
+     * and can be regenerated from cert->raw.
+     */
+    cert->der_size = der_len;
+    /* store raw pointer - ownership transfers to cert */
+    cert->raw = (uint8_t *)buf;

...then use g_steal_pointer. It'll read better and the comment wouldn't be needed to explain what's happening.

Quoted 22 lines
hw/s390x/cert-store.c new file +22 -0
+
+    /*
+     * Left justified certificate name with padding on the right with blanks.
+     * Convert certificate name to EBCDIC.
+     */
+    strpadcpy(name, CERT_NAME_MAX_LEN, filename, ' ');
+    ebcdic_put(cert->name, name, CERT_NAME_MAX_LEN);
+
+    return cert;
+}
+
+static void update_cert_store(S390IPLCertificateStore *cert_store,
+                              S390IPLCertificate *cert)
+{
+    size_t data_buf_size;
+    size_t keyid_buf_size;
+    size_t hash_buf_size;
+    size_t cert_buf_size;
+
+    /* length field is word aligned for later DIAG use */
+    keyid_buf_size = ROUND_UP(CERT_KEY_ID_LEN, 4);
+    hash_buf_size = ROUND_UP(CERT_HASH_LEN, 4);

hw/s390x/cert-store.c line 96

Quoted 10 lines
hw/s390x/cert-store.c new file +10 -0
+    cert_buf_size = ROUND_UP(cert->der_size, 4);
+    data_buf_size = keyid_buf_size + hash_buf_size + cert_buf_size;
+
+    if (cert_store->largest_cert_size < data_buf_size) {
+        cert_store->largest_cert_size = data_buf_size;
+    }
+
+    g_assert(cert_store->count < MAX_CERTIFICATES);
+
+    cert_store->certs[cert_store->count] = *cert;

Should a g_steal_pointer be used here?

hw/s390x/cert-store.c line 100

Quoted 4 lines
hw/s390x/cert-store.c new file +4 -0
+    cert_store->total_bytes += data_buf_size;
+    cert_store->count++;
+}
+

Functionally, things look good to me.

Signature · 2 lines
Regards,
  Collin
#6 lore raw

Re: [PATCH v11 04/32] hw/s390x/ipl: Create certificate store

Thanks for the feedback!

Quoted 18 lines · Collin Walling
Quoted 7 lines · Zhuoying Cai

Create a certificate store for boot certificates used for secure IPL.

Load certificates from the boot-certs parameter of s390-ccw-virtio machine type option into the cert store.

Currently, only X.509 certificates in PEM format are supported, as the QEMU command line accepts certificates in PEM format only.

Let's add more context here:

"The raw Base64 data is stored, as well as the certificate's size. The binary (DER) size is stored as well, which may later be utilized for secure boot (signature verification)."

Quoted 3 lines

[...]

Quoted 16 lines
Quoted 16 lines
hw/s390x/cert-store.c new file +16 -0
+
+static void update_cert_store(S390IPLCertificateStore *cert_store,
+                              S390IPLCertificate *cert)
+{
+    size_t data_buf_size;
+    size_t keyid_buf_size;
+    size_t hash_buf_size;
+    size_t cert_buf_size;
+
+    /* length field is word aligned for later DIAG use */
+    keyid_buf_size = ROUND_UP(CERT_KEY_ID_LEN, 4);
+    hash_buf_size = ROUND_UP(CERT_HASH_LEN, 4);
+    cert_buf_size = ROUND_UP(cert->der_size, 4);
+    data_buf_size = keyid_buf_size + hash_buf_size + cert_buf_size;
+
+    if (cert_store->largest_cert_size < data_buf_size) {
Quoted 9 lines

hw/s390x/cert-store.c line 96

Quoted 6 lines
hw/s390x/cert-store.c new file +6 -0
+        cert_store->largest_cert_size = data_buf_size;
+    }
+
+    g_assert(cert_store->count < MAX_CERTIFICATES);
+
+    cert_store->certs[cert_store->count] = *cert;

Should a g_steal_pointer be used here?

No, g_steal_pointer is not needed here. This line performs a struct copy, not a pointer assignment and no ownership transfer. The entire S390IPLCertificate is copied by value into this array.

Quoted 7 lines

hw/s390x/cert-store.c line 100

Quoted 4 lines
hw/s390x/cert-store.c new file +4 -0
+    cert_store->total_bytes += data_buf_size;
+    cert_store->count++;
+}
+

Functionally, things look good to me.

#7 lore raw

PATCH v11 5/32 s390x/diag: Introduce DIAG 320 for Certificate Store Facility

In reply to Zhuoying Cai

DIAGNOSE 320 is introduced to support Certificate Store (CS) Facility, which includes operations such as query certificate storage information and provide certificates in the certificate store.

Currently, only subcode 0 is supported with this patch, which is used to query the Installed Subcodes Mask (ISM).

This subcode is only supported when the CS facility is enabled.

Availability of CS facility is determined by byte 134 bit 5 of the SCLP Read Info block. Byte 134's facilities cannot be represented without the availability of the extended-length-SCCB, so add it as a check for consistency.

Note: secure IPL is not available for Secure Execution (SE) guests, as their images are already integrity protected, and an additional protection of the kernel by secure IPL is not necessary.

This feature is available starting with the gen16 CPU model.

---
 docs/specs/s390x-secure-ipl.rst     | 12 +++++++++
 include/hw/s390x/ipl/diag320.h      | 20 ++++++++++++++
 target/s390x/cpu_features.c         |  1 +
 target/s390x/cpu_features_def.h.inc |  1 +
 target/s390x/cpu_models.c           |  2 ++
 target/s390x/diag.c                 | 42 +++++++++++++++++++++++++++++
 target/s390x/gen-features.c         |  3 +++
 target/s390x/kvm/kvm.c              | 16 +++++++++++
 target/s390x/s390x-internal.h       |  2 ++
 target/s390x/tcg/misc_helper.c      |  7 +++++
 10 files changed, 106 insertions(+)
 create mode 100644 include/hw/s390x/ipl/diag320.h
docs/specs/s390x-secure-ipl.rst +12 -0
index 1cdf19783f..5f7b5bf559 100644
@@ -14,3 +14,15 @@ and a summation of the sizes.
 
 Note: A maximum of 64 certificates are allowed to be stored in the certificate
 store.
+
+DIAGNOSE function code 'X'320' - Certificate Store Facility
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+DIAGNOSE 'X'320' is used to provide support for guest code to directly
+query the s390 certificate store. Guest code may be the s390-ccw BIOS or
+the guest kernel.
+
+Subcode 0 - query installed subcodes
+    Returns a 256-bit installed subcodes mask (ISM) stored in the installed
+    subcodes block (ISB). This mask indicates which subcodes are currently
+    installed and available for use.
include/hw/s390x/ipl/diag320.h new file +20 -0
new file mode 100644
index 0000000000..aa04b699c6
@@ -0,0 +1,20 @@
+/*
+ * S/390 DIAGNOSE 320 definitions and structures
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef S390X_DIAG320_H
+#define S390X_DIAG320_H
+
+#define DIAG_320_SUBC_QUERY_ISM     0
+
+#define DIAG_320_RC_OK              0x0001
+#define DIAG_320_RC_NOT_SUPPORTED   0x0102
+
+#define DIAG_320_ISM_QUERY_SUBCODES 0x80000000
+
+#endif
target/s390x/cpu_features.c +1 -0
index 4b5be6798e..436471f4b4 100644
@@ -147,6 +147,7 @@ void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
         break;
     case S390_FEAT_TYPE_SCLP_FAC134:
         clear_be_bit(s390_feat_def(S390_FEAT_DIAG_318)->bit, data);
+        clear_be_bit(s390_feat_def(S390_FEAT_CERT_STORE)->bit, data);
         break;
     default:
         return;
target/s390x/cpu_features_def.h.inc +1 -0
index c017bffcdc..2976ecd0ee 100644
@@ -138,6 +138,7 @@ DEF_FEAT(SIE_IBS, "ibs", SCLP_CONF_CHAR_EXT, 10, "SIE: Interlock-and-broadcast-s
 
 /* Features exposed via SCLP SCCB Facilities byte 134 (bit numbers relative to byte-134) */
 DEF_FEAT(DIAG_318, "diag318", SCLP_FAC134, 0, "Control program name and version codes")
+DEF_FEAT(CERT_STORE, "cstore", SCLP_FAC134, 5, "Certificate Store functions")
 
 /* Features exposed via SCLP CPU info. */
 DEF_FEAT(SIE_F2, "sief2", SCLP_CPU, 4, "SIE: interception format 2 (Virtual SIE)")
target/s390x/cpu_models.c +2 -0
index 0b88868289..962f135f42 100644
@@ -248,6 +248,7 @@ bool s390_has_feat(S390Feat feat)
     if (s390_is_pv()) {
         switch (feat) {
         case S390_FEAT_DIAG_318:
+        case S390_FEAT_CERT_STORE:
         case S390_FEAT_HPMA2:
         case S390_FEAT_SIE_F2:
         case S390_FEAT_SIE_SKEY:
@@ -505,6 +506,7 @@ static void check_consistency(const S390CPUModel *model)
         { S390_FEAT_PTFF_STOUE, S390_FEAT_MULTIPLE_EPOCH },
         { S390_FEAT_AP_QUEUE_INTERRUPT_CONTROL, S390_FEAT_AP },
         { S390_FEAT_DIAG_318, S390_FEAT_EXTENDED_LENGTH_SCCB },
+        { S390_FEAT_CERT_STORE, S390_FEAT_EXTENDED_LENGTH_SCCB },
         { S390_FEAT_NNPA, S390_FEAT_VECTOR },
         { S390_FEAT_RDP, S390_FEAT_LOCAL_TLB_CLEARING },
         { S390_FEAT_UV_FEAT_AP, S390_FEAT_AP },
target/s390x/diag.c +42 -0

51 lines not on this page · raw message

target/s390x/gen-features.c +3 -0
index 8218e6470e..6c20c3a862 100644
@@ -720,6 +720,7 @@ static uint16_t full_GEN16_GA1[] = {
     S390_FEAT_PAIE,
     S390_FEAT_UV_FEAT_AP,
     S390_FEAT_UV_FEAT_AP_INTR,
+    S390_FEAT_CERT_STORE,
 };
 
 static uint16_t full_GEN17_GA1[] = {
@@ -919,6 +920,8 @@ static uint16_t qemu_MAX[] = {
     S390_FEAT_KIMD_SHA_512,
     S390_FEAT_KLMD_SHA_512,
     S390_FEAT_PRNO_TRNG,
+    S390_FEAT_EXTENDED_LENGTH_SCCB,
+    S390_FEAT_CERT_STORE,
 };
 
 /****** END FEATURE DEFS ******/
target/s390x/kvm/kvm.c +16 -0
index 2e4f435c53..a5411859a8 100644
@@ -99,6 +99,7 @@
 #define DIAG_TIMEREVENT                 0x288
 #define DIAG_IPL                        0x308
 #define DIAG_SET_CONTROL_PROGRAM_CODES  0x318
+#define DIAG_CERT_STORE                 0x320
 #define DIAG_KVM_HYPERCALL              0x500
 #define DIAG_KVM_BREAKPOINT             0x501
 
@@ -1531,6 +1532,16 @@ static void handle_diag_318(S390CPU *cpu, struct kvm_run *run)
     }
 }
 
+static void kvm_handle_diag_320(S390CPU *cpu, struct kvm_run *run)
+{
+    uint64_t r1, r3;
+
+    r1 = (run->s390_sieic.ipa & 0x00f0) >> 4;
+    r3 = run->s390_sieic.ipa & 0x000f;
+
+    handle_diag_320(&cpu->env, r1, r3, RA_IGNORED);
+}
+
 #define DIAG_KVM_CODE_MASK 0x000000000000ffff
 
 static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
@@ -1561,6 +1572,9 @@ static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
     case DIAG_KVM_BREAKPOINT:
         r = handle_sw_breakpoint(cpu, run);
         break;
+    case DIAG_CERT_STORE:
+        kvm_handle_diag_320(cpu, run);
+        break;
     default:
         trace_kvm_insn_diag(func_code);
         kvm_s390_program_interrupt(cpu, PGM_SPECIFICATION);
@@ -2462,6 +2476,8 @@ bool kvm_s390_get_host_cpu_model(S390CPUModel *model, Error **errp)
         set_bit(S390_FEAT_DIAG_318, model->features);
     }
 
+    set_bit(S390_FEAT_CERT_STORE, model->features);
+
     /* Test for Ultravisor features that influence secure guest behavior */
     query_uv_feat_guest(model->features);
 
target/s390x/s390x-internal.h +2 -0
index 40850bcdc4..b16490bce6 100644
@@ -388,6 +388,8 @@ int mmu_translate_real(CPUS390XState *env, hwaddr raddr, int rw,
 int handle_diag_288(CPUS390XState *env, uint64_t r1, uint64_t r3);
 void handle_diag_308(CPUS390XState *env, uint64_t r1, uint64_t r3,
                      uintptr_t ra);
+void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3,
+                     uintptr_t ra);
 
 
 /* translate.c */
target/s390x/tcg/misc_helper.c +7 -0
index 1fd900fbbf..4d73475d95 100644
@@ -142,6 +142,13 @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num)
         /* time bomb (watchdog) */
         r = handle_diag_288(env, r1, r3);
         break;
+    case 0x320:
+        /* cert store */
+        bql_lock();
+        handle_diag_320(env, r1, r3, GETPC());
+        bql_unlock();
+        r = 0;
+        break;
     default:
         r = -1;
         break;
Signature · 1 line
2.54.0
#8 lore raw

PATCH v11 6/32 s390x/diag: Refactor address validation check from diag308_parm_check

In reply to Zhuoying Cai

Create a function to validate the address parameter of DIAGNOSE.

Refactor the function for reuse in the next patch, which allows address validation in read or write operation of DIAGNOSE.

---
 target/s390x/diag.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)
target/s390x/diag.c +7 -3
index 6373544bb2..8ab40437a2 100644
@@ -26,6 +26,12 @@
 #include "qemu/error-report.h"
 
 
+static inline bool diag_parm_addr_valid(uint64_t addr, size_t size, bool write)
+{
+    return address_space_access_valid(&address_space_memory, addr,
+                                      size, write, MEMTXATTRS_UNSPECIFIED);
+}
+
 int handle_diag_288(CPUS390XState *env, uint64_t r1, uint64_t r3)
 {
     uint64_t func = env->regs[r1];
@@ -65,9 +71,7 @@ static int diag308_parm_check(CPUS390XState *env, uint64_t r1, uint64_t addr,
         s390_program_interrupt(env, PGM_SPECIFICATION, ra);
         return -1;
     }
-    if (!address_space_access_valid(&address_space_memory, addr,
-                                    sizeof(IplParameterBlock), write,
-                                    MEMTXATTRS_UNSPECIFIED)) {
+    if (!diag_parm_addr_valid(addr, sizeof(IplParameterBlock), write)) {
         s390_program_interrupt(env, PGM_ADDRESSING, ra);
         return -1;
     }
Signature · 1 line
2.54.0
#9 lore raw

PATCH v11 7/32 s390x/diag: Implement DIAG 320 subcode 1

In reply to Zhuoying Cai

DIAG 320 subcode 1 provides information needed to determine the amount of storage to store one or more certificates from the certificate store.

Upon successful completion, this subcode returns information of the current cert store, such as the number of certificates stored and allowed in the cert store, amount of space may need to be allocate to store a certificate, etc for verification-certificate blocks (VCBs).

The subcode value is denoted by setting the left-most bit of an 8-byte field.

The verification-certificate-storage-size block (VCSSB) contains the output data when the operation completes successfully. A VCSSB length of 4 indicates that no certificate are available in the cert store.

---
 docs/specs/s390x-secure-ipl.rst | 12 ++++++
 hw/s390x/cert-store.h           |  3 +-
 include/hw/s390x/ipl/diag320.h  | 57 +++++++++++++++++++++++++++++
 target/s390x/diag.c             | 65 ++++++++++++++++++++++++++++++++-
 4 files changed, 134 insertions(+), 3 deletions(-)
docs/specs/s390x-secure-ipl.rst +12 -0
index 5f7b5bf559..807a8ae393 100644
@@ -26,3 +26,15 @@ Subcode 0 - query installed subcodes
     Returns a 256-bit installed subcodes mask (ISM) stored in the installed
     subcodes block (ISB). This mask indicates which subcodes are currently
     installed and available for use.
+
+Subcode 1 - query verification certificate storage information
+    Provides the information required to determine the amount of memory needed
+    to store one or more verification-certificates (VCs) from the certificate
+    store (CS).
+
+    Upon successful completion, this subcode returns various storage size values
+    for verification-certificate blocks (VCBs).
+
+    The output is returned in the verification-certificate-storage-size block
+    (VCSSB). A VCSSB length of 4 indicates that no certificates are available
+    in the CS.
hw/s390x/cert-store.h +1 -2
index 7fc9503cb9..6f5ee63177 100644
@@ -11,10 +11,9 @@
 #define HW_S390_CERT_STORE_H
 
 #include "hw/s390x/ipl/qipl.h"
+#include "hw/s390x/ipl/diag320.h"
 #include "crypto/x509-utils.h"
 
-#define CERT_NAME_MAX_LEN  64
-
 #define CERT_KEY_ID_LEN    QCRYPTO_HASH_DIGEST_LEN_SHA256
 #define CERT_HASH_LEN      QCRYPTO_HASH_DIGEST_LEN_SHA256
 
include/hw/s390x/ipl/diag320.h +57 -0

67 lines not on this page · raw message

target/s390x/diag.c +64 -1

88 lines not on this page · raw message

Signature · 1 line
2.54.0
#10 lore raw

PATCH v11 8/32 crypto/x509-utils: Add helper functions for DIAG 320 subcode 2

In reply to Zhuoying Cai

Introduce new helper functions to extract certificate metadata:

qcrypto_x509_check_cert_times() - validates the certificate's validity period against the current time qcrypto_x509_get_cert_key_id() - extracts the key ID from the certificate qcrypto_x509_check_ecc_curve_p521() - determines the ECC public key algorithm uses P-521 curve

These functions provide support for metadata extraction and validity checking for X.509 certificates.

---
 crypto/x509-utils.c         | 236 ++++++++++++++++++++++++++++++++++++
 include/crypto/x509-utils.h |  51 ++++++++
 2 files changed, 287 insertions(+)
crypto/x509-utils.c +236 -0
index 68cf008938..7dd8d1a0e9 100644
@@ -27,6 +27,16 @@ static const int qcrypto_to_gnutls_hash_alg_map[QCRYPTO_HASH_ALGO__MAX] = {
     [QCRYPTO_HASH_ALGO_RIPEMD160] = GNUTLS_DIG_RMD160,
 };
 
+static const int qcrypto_to_gnutls_keyid_flags_map[] = {
+    [QCRYPTO_HASH_ALGO_MD5] = -1,
+    [QCRYPTO_HASH_ALGO_SHA1] = GNUTLS_KEYID_USE_SHA1,
+    [QCRYPTO_HASH_ALGO_SHA224] = -1,
+    [QCRYPTO_HASH_ALGO_SHA256] = GNUTLS_KEYID_USE_SHA256,
+    [QCRYPTO_HASH_ALGO_SHA384] = -1,
+    [QCRYPTO_HASH_ALGO_SHA512] = GNUTLS_KEYID_USE_SHA512,
+    [QCRYPTO_HASH_ALGO_RIPEMD160] = -1,
+};
+
 int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
                                       QCryptoHashAlgo alg,
                                       uint8_t *result,
@@ -121,6 +131,210 @@ cleanup:
     return ret;
 }
 
+int qcrypto_x509_check_cert_times(uint8_t *cert, size_t size, Error **errp)
+{
+    int rc;
+    int ret = -1;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+    time_t now = time(NULL);
+    time_t exp_time;
+    time_t act_time;
+
+    if (now == ((time_t)-1)) {
+        error_setg_errno(errp, errno, "Cannot get current time");
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    exp_time = gnutls_x509_crt_get_expiration_time(crt);
+    if (exp_time == ((time_t)-1)) {
+        error_setg(errp, "Failed to get certificate expiration time");
+        goto cleanup;
+    }
+    if (exp_time < now) {
+        error_setg(errp, "The certificate has expired");
+        goto cleanup;
+    }
+
+    act_time = gnutls_x509_crt_get_activation_time(crt);
+    if (act_time == ((time_t)-1)) {
+        error_setg(errp, "Failed to get certificate activation time");
+        goto cleanup;
+    }
+    if (act_time > now) {
+        error_setg(errp, "The certificate is not yet active");
+        goto cleanup;
+    }
+
+    ret = 0;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    return ret;
+}
+
+static int qcrypto_x509_get_pk_algorithm(uint8_t *cert, size_t size, Error **errp)
+{
+    int rc;
+    int ret = -1;
+    unsigned int bits;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_x509_crt_get_pk_algorithm(crt, &bits);
+    if (rc < 0) {
+        error_setg(errp, "Unknown public key algorithm %d", rc);
+        goto cleanup;
+    }
+
+    ret = rc;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    return ret;
+}
+
+int qcrypto_x509_get_cert_key_id(uint8_t *cert, size_t size,
+                                 QCryptoHashAlgo hash_alg,
+                                 uint8_t **result,
+                                 size_t *resultlen,
+                                 Error **errp)
+{
+    int rc;
+    int ret = -1;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+
+    if (hash_alg >= G_N_ELEMENTS(qcrypto_to_gnutls_hash_alg_map)) {
+        error_setg(errp, "Unknown hash algorithm %d", hash_alg);
+        return ret;
+    }
+
+    if (hash_alg >= G_N_ELEMENTS(qcrypto_to_gnutls_keyid_flags_map) ||
+        qcrypto_to_gnutls_keyid_flags_map[hash_alg] == -1) {
+        error_setg(errp, "Unsupported key id flag %d", hash_alg);
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    *resultlen = gnutls_hash_get_len(qcrypto_to_gnutls_hash_alg_map[hash_alg]);
+    if (*resultlen == 0) {
+        error_setg(errp, "Failed to get hash algorithn length: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    *result = g_malloc0(*resultlen);
+    if (gnutls_x509_crt_get_key_id(crt,
+                                   qcrypto_to_gnutls_keyid_flags_map[hash_alg],
+                                   *result, resultlen) != 0) {
+        error_setg(errp, "Failed to get key ID from certificate");
+        g_clear_pointer(result, g_free);
+        goto cleanup;
+    }
+
+    ret = 0;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    return ret;
+}
+
+static int qcrypto_x509_get_ecc_curve(uint8_t *cert, size_t size, Error **errp)
+{
+    int rc;
+    int ret = -1;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+    gnutls_ecc_curve_t curve_id;
+    gnutls_datum_t x = {.data = NULL, .size = 0};
+    gnutls_datum_t y = {.data = NULL, .size = 0};
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_x509_crt_get_pk_ecc_raw(crt, &curve_id, &x, &y);
+    if (rc != 0) {
+        error_setg(errp, "Failed to get ECC public key curve: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    ret = curve_id;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    g_free(x.data);
+    g_free(y.data);
+    return ret;
+}
+
+int qcrypto_x509_check_ecc_curve_p521(uint8_t *cert, size_t size, Error **errp)
+{
+    int algo;
+    int curve_id;
+
+    algo = qcrypto_x509_get_pk_algorithm(cert, size, errp);
+    if (algo != GNUTLS_PK_ECDSA) {
+        return 0;
+    }
+
+    curve_id = qcrypto_x509_get_ecc_curve(cert, size, errp);
+    if (curve_id == -1) {
+        error_setg(errp, "Failed to get ECC curve");
+        return -1;
+    }
+
+    if (curve_id == GNUTLS_ECC_CURVE_INVALID) {
+        error_setg(errp, "Invalid ECC curve");
+        return -1;
+    }
+
+    return curve_id == GNUTLS_ECC_CURVE_SECP521R1;
+}
+
 #else /* ! CONFIG_GNUTLS */
 
 int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
@@ -142,4 +356,26 @@ int qcrypto_x509_convert_cert_der(uint8_t *cert, size_t size,
     return -1;
 }
 
+int qcrypto_x509_check_cert_times(uint8_t *cert, size_t size, Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to get certificate times");
+    return -1;
+}
+
+int qcrypto_x509_get_cert_key_id(uint8_t *cert, size_t size,
+                                 QCryptoHashAlgo hash_alg,
+                                 uint8_t **result,
+                                 size_t *resultlen,
+                                 Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to get key ID");
+    return -1;
+}
+
+int qcrypto_x509_check_ecc_curve_p521(uint8_t *cert, size_t size, Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to determine ecc curve");
+    return -1;
+}
+
 #endif /* ! CONFIG_GNUTLS */
include/crypto/x509-utils.h +51 -0

55 lines not on this page · raw message

Signature · 1 line
2.54.0
#11 lore raw

Re: [PATCH v11 08/32] crypto/x509-utils: Add helper functions for DIAG 320 subcode 2

Quoted 1 line · Zhuoying Cai

Introduce new helper functions to extract certificate metadata:

Just a few typos.

Quoted 27 lines
crypto/x509-utils.c +27 -0
+int qcrypto_x509_get_cert_key_id(uint8_t *cert, size_t size,
+                                 QCryptoHashAlgo hash_alg,
+                                 uint8_t **result,
+                                 size_t *resultlen,
+                                 Error **errp)
+{
+    int rc;
+    int ret = -1;
+    gnutls_x509_crt_t crt;
+    gnutls_datum_t datum = {.data = cert, .size = size};
+
+    if (hash_alg >= G_N_ELEMENTS(qcrypto_to_gnutls_hash_alg_map)) {
+        error_setg(errp, "Unknown hash algorithm %d", hash_alg);
+        return ret;
+    }
+
+    if (hash_alg >= G_N_ELEMENTS(qcrypto_to_gnutls_keyid_flags_map) ||
+        qcrypto_to_gnutls_keyid_flags_map[hash_alg] == -1) {
+        error_setg(errp, "Unsupported key id flag %d", hash_alg);
+        return ret;
+    }
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        return ret;
+    }

crypto/x509-utils.c cleanup: · line 257

Quoted 10 lines
crypto/x509-utils.c +10 -0
+
+    rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    *resultlen = gnutls_hash_get_len(qcrypto_to_gnutls_hash_alg_map[hash_alg]);
+    if (*resultlen == 0) {
+        error_setg(errp, "Failed to get hash algorithn length: %s", gnutls_strerror(rc));

s/algorithn/algorithm

Quoted 3 lines
crypto/x509-utils.c +3 -0
+        goto cleanup;
+    }
+

[...]

Quoted 16 lines
include/crypto/x509-utils.h +16 -0
+/**
+ * qcrypto_x509_check_cert_times
+ * @cert: pointer to the raw certificate data
+ * @size: size of the certificate
+ * @errp: error pointer
+ *
+ * Check whether the activation and expiration times of @cert
+ * are valid at the current time.
+ *
+ * Returns: 0 if the certificate times are valid,
+ *         -1 on error.
+ */
+int qcrypto_x509_check_cert_times(uint8_t *cert, size_t size, Error **errp);
+
+/**
+ * qcrypto_x509_get_cert_key_id

include/crypto/x509-utils.h int qcrypto_x509_convert_cert_der(uint8_t *cert, size_t size, · line 68

Quoted 10 lines
include/crypto/x509-utils.h +10 -0
+ * @cert: pointer to the raw certificate data
+ * @size: size of the certificate
+ * @hash_alg: the hash algorithm flag
+ * @result: output location for the allocated buffer for key ID
+ *          (the function allocates memory which must be freed by the caller)
+ * @resultlen: pointer to the size of the buffer
+ *             (will be updated with the actual size of key id)
+ * @errp: error pointer
+ *
+ * Retrieve the key ID from the @cert based on the specified @flag.

s/@flag/@hash_alg ?

Signature · 2 lines
Regards,
  Collin
#12 lore raw

PATCH v11 9/32 s390x/diag: Implement DIAG 320 subcode 2

In reply to Zhuoying Cai

DIAG 320 subcode 2 provides verification-certificates (VCs) that are in the certificate store. Only X509 certificates in DER format and SHA-256 hash type are recognized.

The subcode value is denoted by setting the second-left-most bit of an 8-byte field.

The Verification Certificate Block (VCB) contains the output data when the operation completes successfully. It includes a common header followed by zero or more Verification Certificate Entries (VCEs), depending on the VCB input length and the VC range (from the first VC index to the last VC index) in the certificate store.

Each VCE contains information about a certificate retrieved from the S390IPLCertificateStore, such as the certificate name, key type, key ID length, hash length, and the raw certificate data.
The key ID and hash are extracted from the raw certificate by the crypto API.

Note: SHA2-256 VC hash type is required for retrieving the hash (fingerprint) of the certificate.

---
 docs/specs/s390x-secure-ipl.rst |  24 +++
 include/hw/s390x/ipl/diag320.h  |  29 +++
 target/s390x/diag.c             | 339 +++++++++++++++++++++++++++++++-
 3 files changed, 391 insertions(+), 1 deletion(-)
docs/specs/s390x-secure-ipl.rst +24 -0
index 807a8ae393..d9c5c24ec7 100644
@@ -38,3 +38,27 @@ Subcode 1 - query verification certificate storage information
     The output is returned in the verification-certificate-storage-size block
     (VCSSB). A VCSSB length of 4 indicates that no certificates are available
     in the CS.
+
+Subcode 2 - store verification certificates
+    Provides VCs that are in the certificate store.
+
+    The output is provided in a VCB, which includes a common header followed by
+    zero or more verification-certificate entries (VCEs).
+
+    The instruction expects the cert store to maintain an origin of 1 for the
+    index (i.e. a retrieval of the first certificate in the store should be
+    denoted by setting first-VC to 1).
+
+    The first-VC and last-VC fields of the VCB specify the index range of
+    VCs to be stored in the VCB. Certs are stored sequentially, starting
+    with first-VC index. As each cert is stored, a "stored count" is
+    incremented. If there is not enough space to store all certs requested
+    by the index range, a "remaining count" will be recorded and no more
+    certificates will be stored.
+
+    Each VCE contains a header followed by information extracted from a
+    certificate within the certificate store. The information includes:
+    key-id, hash, and certificate data. This information is stored
+    contiguously in a VCE (with zero-padding). Following the header, the
+    key-id is immediately stored. The hash and certificate data follow and
+    may be accessed via the respective offset fields stored in the VCE.
include/hw/s390x/ipl/diag320.h +29 -0
index 90797728d8..35c652ff56 100644
@@ -12,19 +12,36 @@
 
 #define DIAG_320_SUBC_QUERY_ISM     0
 #define DIAG_320_SUBC_QUERY_VCSI    1
+#define DIAG_320_SUBC_STORE_VC      2
 
 #define DIAG_320_RC_OK              0x0001
 #define DIAG_320_RC_NOT_SUPPORTED   0x0102
 #define DIAG_320_RC_INVAL_VCSSB_LEN 0x0202
+#define DIAG_320_RC_INVAL_VCB_LEN   0x0204
+#define DIAG_320_RC_BAD_RANGE       0x0302
 
 #define DIAG_320_ISM_QUERY_SUBCODES 0x80000000
 #define DIAG_320_ISM_QUERY_VCSI     0x40000000
+#define DIAG_320_ISM_STORE_VC       0x20000000
 
 #define VCSSB_NO_VC     4
 #define VCSSB_MIN_LEN   128
 
 #define CERT_NAME_MAX_LEN  64
 
+/*
+ * If the VCE flags indicate an invalid certificate,
+ * the VCE length is set to 72, containing only the
+ * first five fields of VCEntry.
+ */
+#define VCE_INVALID_LEN 72
+
+#define DIAG_320_VCE_FLAGS_VALID                0x80
+#define DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING    0
+#define DIAG_320_VCE_KEYTYPE_ECDSA_P521         1
+#define DIAG_320_VCE_FORMAT_X509_DER            1
+#define DIAG_320_VCE_HASHTYPE_SHA2_256          1
+
 struct VCStorageSizeBlock {
     uint32_t length;
     uint8_t reserved0[3];
@@ -60,6 +77,12 @@ struct VCEntryHeader {
 };
 typedef struct VCEntryHeader VCEntryHeader;
 
+struct VCEntry {
+    VCEntryHeader vce_hdr;
+    uint8_t cert_buf[];
+};
+typedef struct VCEntry VCEntry;
+
 struct VCBlockHeader {
     uint32_t in_len;
     uint32_t reserved0;
@@ -74,4 +97,10 @@ struct VCBlockHeader {
 };
 typedef struct VCBlockHeader VCBlockHeader;
 
+struct VCBlock {
+    VCBlockHeader vcb_hdr;
+    uint8_t vce_buf[];
+};
+typedef struct VCBlock VCBlock;
+
 #endif
target/s390x/diag.c +338 -1

372 lines not on this page · raw message

Signature · 1 line
2.54.0
#13 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 427 lines · Zhuoying Cai

DIAG 320 subcode 2 provides verification-certificates (VCs) that are in the certificate store. Only X509 certificates in DER format and SHA-256 hash type are recognized.

The subcode value is denoted by setting the second-left-most bit of an 8-byte field.

The Verification Certificate Block (VCB) contains the output data when the operation completes successfully. It includes a common header followed by zero or more Verification Certificate Entries (VCEs), depending on the VCB input length and the VC range (from the first VC index to the last VC index) in the certificate store.

Each VCE contains information about a certificate retrieved from the S390IPLCertificateStore, such as the certificate name, key type, key ID length, hash length, and the raw certificate data.
The key ID and hash are extracted from the raw certificate by the crypto API.

Note: SHA2-256 VC hash type is required for retrieving the hash (fingerprint) of the certificate.

---
  docs/specs/s390x-secure-ipl.rst |  24 +++
  include/hw/s390x/ipl/diag320.h  |  29 +++
  target/s390x/diag.c             | 339 +++++++++++++++++++++++++++++++-
  3 files changed, 391 insertions(+), 1 deletion(-)
docs/specs/s390x-secure-ipl.rst +24 -0
index 807a8ae393..d9c5c24ec7 100644
@@ -38,3 +38,27 @@ Subcode 1 - query verification certificate storage information
      The output is returned in the verification-certificate-storage-size block
      (VCSSB). A VCSSB length of 4 indicates that no certificates are available
      in the CS.
+
+Subcode 2 - store verification certificates
+    Provides VCs that are in the certificate store.
+
+    The output is provided in a VCB, which includes a common header followed by
+    zero or more verification-certificate entries (VCEs).
+
+    The instruction expects the cert store to maintain an origin of 1 for the
+    index (i.e. a retrieval of the first certificate in the store should be
+    denoted by setting first-VC to 1).
+
+    The first-VC and last-VC fields of the VCB specify the index range of
+    VCs to be stored in the VCB. Certs are stored sequentially, starting
+    with first-VC index. As each cert is stored, a "stored count" is
+    incremented. If there is not enough space to store all certs requested
+    by the index range, a "remaining count" will be recorded and no more
+    certificates will be stored.
+
+    Each VCE contains a header followed by information extracted from a
+    certificate within the certificate store. The information includes:
+    key-id, hash, and certificate data. This information is stored
+    contiguously in a VCE (with zero-padding). Following the header, the
+    key-id is immediately stored. The hash and certificate data follow and
+    may be accessed via the respective offset fields stored in the VCE.
include/hw/s390x/ipl/diag320.h +29 -0
index 90797728d8..35c652ff56 100644
@@ -12,19 +12,36 @@
 
  #define DIAG_320_SUBC_QUERY_ISM     0
  #define DIAG_320_SUBC_QUERY_VCSI    1
+#define DIAG_320_SUBC_STORE_VC      2
 
  #define DIAG_320_RC_OK              0x0001
  #define DIAG_320_RC_NOT_SUPPORTED   0x0102
  #define DIAG_320_RC_INVAL_VCSSB_LEN 0x0202
+#define DIAG_320_RC_INVAL_VCB_LEN   0x0204
+#define DIAG_320_RC_BAD_RANGE       0x0302
 
  #define DIAG_320_ISM_QUERY_SUBCODES 0x80000000
  #define DIAG_320_ISM_QUERY_VCSI     0x40000000
+#define DIAG_320_ISM_STORE_VC       0x20000000
 
  #define VCSSB_NO_VC     4
  #define VCSSB_MIN_LEN   128
 
  #define CERT_NAME_MAX_LEN  64
 
+/*
+ * If the VCE flags indicate an invalid certificate,
+ * the VCE length is set to 72, containing only the
+ * first five fields of VCEntry.
+ */
+#define VCE_INVALID_LEN 72
+
+#define DIAG_320_VCE_FLAGS_VALID                0x80
+#define DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING    0
+#define DIAG_320_VCE_KEYTYPE_ECDSA_P521         1
+#define DIAG_320_VCE_FORMAT_X509_DER            1
+#define DIAG_320_VCE_HASHTYPE_SHA2_256          1
+
  struct VCStorageSizeBlock {
      uint32_t length;
      uint8_t reserved0[3];
@@ -60,6 +77,12 @@ struct VCEntryHeader {
  };
  typedef struct VCEntryHeader VCEntryHeader;
 
+struct VCEntry {
+    VCEntryHeader vce_hdr;
+    uint8_t cert_buf[];
+};
+typedef struct VCEntry VCEntry;
+
  struct VCBlockHeader {
      uint32_t in_len;
      uint32_t reserved0;
@@ -74,4 +97,10 @@ struct VCBlockHeader {
  };
  typedef struct VCBlockHeader VCBlockHeader;
 
+struct VCBlock {
+    VCBlockHeader vcb_hdr;
+    uint8_t vce_buf[];
+};
+typedef struct VCBlock VCBlock;
+
  #endif
target/s390x/diag.c +280 -0
index f531ce9d82..0645fe39dc 100644
@@ -17,13 +17,16 @@
  #include "s390x-internal.h"
  #include "hw/watchdog/wdt_diag288.h"
  #include "system/cpus.h"
+#include "hw/s390x/cert-store.h"
  #include "hw/s390x/ipl.h"
  #include "hw/s390x/ipl/diag320.h"
  #include "hw/s390x/s390-virtio-ccw.h"
  #include "system/kvm.h"
  #include "kvm/kvm_s390x.h"
  #include "target/s390x/kvm/pv.h"
+#include "qapi/error.h"
  #include "qemu/error-report.h"
+#include "crypto/x509-utils.h"
 
 
  static inline bool diag_parm_addr_valid(uint64_t addr, size_t size, bool write)
@@ -238,8 +241,329 @@ static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1,
      return DIAG_320_RC_OK;
  }
 
+static bool is_cert_valid(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_cert_times(cert->raw, cert->size, &err);
+    if (rc != 0) {
+        error_report_err(err);
+        return false;
+    }
+
+    return true;
+}
+
+static int handle_key_id(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    int rc;
+    g_autofree unsigned char *key_id_data = NULL;
+    size_t key_id_len;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_get_cert_key_id(cert->raw, cert->size,
+                                      QCRYPTO_HASH_ALGO_SHA256,
+                                      &key_id_data, &key_id_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    if (sizeof(VCEntryHeader) + key_id_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write key ID: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.keyid_len = cpu_to_be16(key_id_len);
+
+    memcpy(vce->cert_buf, key_id_data, key_id_len);
+
+    return 0;
+}
+
+static int handle_hash(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t keyid_field_len)
+{
+    int rc;
+    uint16_t hash_offset;
+    g_autofree void *hash_data = NULL;
+    size_t hash_len;
+    Error *err = NULL;
+
+    hash_len = CERT_HASH_LEN;
+    hash_data = g_malloc0(hash_len);
+    rc = qcrypto_get_x509_cert_fingerprint(cert->raw, cert->size,
+                                           QCRYPTO_HASH_ALGO_SHA256,
+                                           hash_data, &hash_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    hash_offset = sizeof(VCEntryHeader) + keyid_field_len;
+    if (hash_offset + hash_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write hash: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.hash_len = cpu_to_be16(hash_len);
+    vce->vce_hdr.hash_type = DIAG_320_VCE_HASHTYPE_SHA2_256;
+    vce->vce_hdr.hash_offset = cpu_to_be16(hash_offset);
+
+    memcpy((uint8_t *)vce + hash_offset, hash_data, hash_len);
+
+    return 0;
+}
+
+static int handle_cert(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t hash_field_len)
+{
+    int rc;
+    uint16_t cert_offset;
+    g_autofree uint8_t *cert_der = NULL;
+    size_t der_size;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_convert_cert_der(cert->raw, cert->size,
+                                       &cert_der, &der_size, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    cert_offset = be16_to_cpu(vce->vce_hdr.hash_offset) + hash_field_len;
+    if (cert_offset + der_size > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write certificate: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.format = DIAG_320_VCE_FORMAT_X509_DER;
+    vce->vce_hdr.cert_len = cpu_to_be32(der_size);
+    vce->vce_hdr.cert_offset = cpu_to_be16(cert_offset);
+
+    memcpy((uint8_t *)vce + cert_offset, cert_der, der_size);
+
+    return 0;
+}
+
+static int get_key_type(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_ecc_curve_p521(cert->raw, cert->size, &err);
+    if (rc == -1) {
+        error_report_err(err);
+        return -1;
+    }
+
+    return (rc == 1) ? DIAG_320_VCE_KEYTYPE_ECDSA_P521 :
+                       DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING;
+}
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+
+static int build_vce_data(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    uint16_t keyid_field_len;
+    uint16_t hash_field_len;
+    uint32_t cert_field_len;
+    uint32_t vce_len;
+    int rc;
+
+    rc = handle_key_id(vce, cert);
+    if (rc) {
+        return -1;
+    }
+    keyid_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.keyid_len), 4);
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 530

Quoted 10 lines
target/s390x/diag.c +10 -0
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {

I think we need to convert vce->vce_hdr.len from be32 to cpu? The diag_320_build_vce() will convert the value in to be32.

Quoted 5 lines
target/s390x/diag.c +5 -0
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 545

Quoted 10 lines
target/s390x/diag.c +10 -0
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;

Same as here as we using vce->vce_hdr.len without conversion.

Quoted 53 lines
target/s390x/diag.c +33 -1
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;
#14 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 434 lines · Farhan Ali
Quoted 432 lines · Zhuoying Cai

DIAG 320 subcode 2 provides verification-certificates (VCs) that are in the certificate store. Only X509 certificates in DER format and SHA-256 hash type are recognized.

The subcode value is denoted by setting the second-left-most bit of an 8-byte field.

The Verification Certificate Block (VCB) contains the output data when the operation completes successfully. It includes a common header followed by zero or more Verification Certificate Entries (VCEs), depending on the VCB input length and the VC range (from the first VC index to the last VC index) in the certificate store.

Each VCE contains information about a certificate retrieved from the S390IPLCertificateStore, such as the certificate name, key type, key ID length, hash length, and the raw certificate data.
The key ID and hash are extracted from the raw certificate by the crypto API.

Note: SHA2-256 VC hash type is required for retrieving the hash (fingerprint) of the certificate.

---
  docs/specs/s390x-secure-ipl.rst |  24 +++
  include/hw/s390x/ipl/diag320.h  |  29 +++
  target/s390x/diag.c             | 339 +++++++++++++++++++++++++++++++-
  3 files changed, 391 insertions(+), 1 deletion(-)
docs/specs/s390x-secure-ipl.rst +24 -0
index 807a8ae393..d9c5c24ec7 100644
@@ -38,3 +38,27 @@ Subcode 1 - query verification certificate storage information
      The output is returned in the verification-certificate-storage-size block
      (VCSSB). A VCSSB length of 4 indicates that no certificates are available
      in the CS.
+
+Subcode 2 - store verification certificates
+    Provides VCs that are in the certificate store.
+
+    The output is provided in a VCB, which includes a common header followed by
+    zero or more verification-certificate entries (VCEs).
+
+    The instruction expects the cert store to maintain an origin of 1 for the
+    index (i.e. a retrieval of the first certificate in the store should be
+    denoted by setting first-VC to 1).
+
+    The first-VC and last-VC fields of the VCB specify the index range of
+    VCs to be stored in the VCB. Certs are stored sequentially, starting
+    with first-VC index. As each cert is stored, a "stored count" is
+    incremented. If there is not enough space to store all certs requested
+    by the index range, a "remaining count" will be recorded and no more
+    certificates will be stored.
+
+    Each VCE contains a header followed by information extracted from a
+    certificate within the certificate store. The information includes:
+    key-id, hash, and certificate data. This information is stored
+    contiguously in a VCE (with zero-padding). Following the header, the
+    key-id is immediately stored. The hash and certificate data follow and
+    may be accessed via the respective offset fields stored in the VCE.
include/hw/s390x/ipl/diag320.h +29 -0
index 90797728d8..35c652ff56 100644
@@ -12,19 +12,36 @@
 
  #define DIAG_320_SUBC_QUERY_ISM     0
  #define DIAG_320_SUBC_QUERY_VCSI    1
+#define DIAG_320_SUBC_STORE_VC      2
 
  #define DIAG_320_RC_OK              0x0001
  #define DIAG_320_RC_NOT_SUPPORTED   0x0102
  #define DIAG_320_RC_INVAL_VCSSB_LEN 0x0202
+#define DIAG_320_RC_INVAL_VCB_LEN   0x0204
+#define DIAG_320_RC_BAD_RANGE       0x0302
 
  #define DIAG_320_ISM_QUERY_SUBCODES 0x80000000
  #define DIAG_320_ISM_QUERY_VCSI     0x40000000
+#define DIAG_320_ISM_STORE_VC       0x20000000
 
  #define VCSSB_NO_VC     4
  #define VCSSB_MIN_LEN   128
 
  #define CERT_NAME_MAX_LEN  64
 
+/*
+ * If the VCE flags indicate an invalid certificate,
+ * the VCE length is set to 72, containing only the
+ * first five fields of VCEntry.
+ */
+#define VCE_INVALID_LEN 72
+
+#define DIAG_320_VCE_FLAGS_VALID                0x80
+#define DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING    0
+#define DIAG_320_VCE_KEYTYPE_ECDSA_P521         1
+#define DIAG_320_VCE_FORMAT_X509_DER            1
+#define DIAG_320_VCE_HASHTYPE_SHA2_256          1
+
  struct VCStorageSizeBlock {
      uint32_t length;
      uint8_t reserved0[3];
@@ -60,6 +77,12 @@ struct VCEntryHeader {
  };
  typedef struct VCEntryHeader VCEntryHeader;
 
+struct VCEntry {
+    VCEntryHeader vce_hdr;
+    uint8_t cert_buf[];
+};
+typedef struct VCEntry VCEntry;
+
  struct VCBlockHeader {
      uint32_t in_len;
      uint32_t reserved0;
@@ -74,4 +97,10 @@ struct VCBlockHeader {
  };
  typedef struct VCBlockHeader VCBlockHeader;
 
+struct VCBlock {
+    VCBlockHeader vcb_hdr;
+    uint8_t vce_buf[];
+};
+typedef struct VCBlock VCBlock;
+
  #endif
target/s390x/diag.c +285 -0
index f531ce9d82..0645fe39dc 100644
@@ -17,13 +17,16 @@
  #include "s390x-internal.h"
  #include "hw/watchdog/wdt_diag288.h"
  #include "system/cpus.h"
+#include "hw/s390x/cert-store.h"
  #include "hw/s390x/ipl.h"
  #include "hw/s390x/ipl/diag320.h"
  #include "hw/s390x/s390-virtio-ccw.h"
  #include "system/kvm.h"
  #include "kvm/kvm_s390x.h"
  #include "target/s390x/kvm/pv.h"
+#include "qapi/error.h"
  #include "qemu/error-report.h"
+#include "crypto/x509-utils.h"
 
 
  static inline bool diag_parm_addr_valid(uint64_t addr, size_t size, bool write)
@@ -238,8 +241,329 @@ static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1,
      return DIAG_320_RC_OK;
  }
 
+static bool is_cert_valid(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_cert_times(cert->raw, cert->size, &err);
+    if (rc != 0) {
+        error_report_err(err);
+        return false;
+    }
+
+    return true;
+}
+
+static int handle_key_id(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    int rc;
+    g_autofree unsigned char *key_id_data = NULL;
+    size_t key_id_len;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_get_cert_key_id(cert->raw, cert->size,
+                                      QCRYPTO_HASH_ALGO_SHA256,
+                                      &key_id_data, &key_id_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    if (sizeof(VCEntryHeader) + key_id_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write key ID: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.keyid_len = cpu_to_be16(key_id_len);
+
+    memcpy(vce->cert_buf, key_id_data, key_id_len);
+
+    return 0;
+}
+
+static int handle_hash(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t keyid_field_len)
+{
+    int rc;
+    uint16_t hash_offset;
+    g_autofree void *hash_data = NULL;
+    size_t hash_len;
+    Error *err = NULL;
+
+    hash_len = CERT_HASH_LEN;
+    hash_data = g_malloc0(hash_len);
+    rc = qcrypto_get_x509_cert_fingerprint(cert->raw, cert->size,
+                                           QCRYPTO_HASH_ALGO_SHA256,
+                                           hash_data, &hash_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    hash_offset = sizeof(VCEntryHeader) + keyid_field_len;
+    if (hash_offset + hash_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write hash: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.hash_len = cpu_to_be16(hash_len);
+    vce->vce_hdr.hash_type = DIAG_320_VCE_HASHTYPE_SHA2_256;
+    vce->vce_hdr.hash_offset = cpu_to_be16(hash_offset);
+
+    memcpy((uint8_t *)vce + hash_offset, hash_data, hash_len);
+
+    return 0;
+}
+
+static int handle_cert(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t hash_field_len)
+{
+    int rc;
+    uint16_t cert_offset;
+    g_autofree uint8_t *cert_der = NULL;
+    size_t der_size;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_convert_cert_der(cert->raw, cert->size,
+                                       &cert_der, &der_size, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    cert_offset = be16_to_cpu(vce->vce_hdr.hash_offset) + hash_field_len;
+    if (cert_offset + der_size > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write certificate: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.format = DIAG_320_VCE_FORMAT_X509_DER;
+    vce->vce_hdr.cert_len = cpu_to_be32(der_size);
+    vce->vce_hdr.cert_offset = cpu_to_be16(cert_offset);
+
+    memcpy((uint8_t *)vce + cert_offset, cert_der, der_size);
+
+    return 0;
+}
+
+static int get_key_type(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_ecc_curve_p521(cert->raw, cert->size, &err);
+    if (rc == -1) {
+        error_report_err(err);
+        return -1;
+    }
+
+    return (rc == 1) ? DIAG_320_VCE_KEYTYPE_ECDSA_P521 :
+                       DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING;
+}
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+
+static int build_vce_data(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    uint16_t keyid_field_len;
+    uint16_t hash_field_len;
+    uint32_t cert_field_len;
+    uint32_t vce_len;
+    int rc;
+
+    rc = handle_key_id(vce, cert);
+    if (rc) {
+        return -1;
+    }
+    keyid_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.keyid_len), 4);
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
Quoted 10 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 530

Quoted 5 lines
target/s390x/diag.c +5 -0
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {

I think we need to convert vce->vce_hdr.len from be32 to cpu? The diag_320_build_vce() will convert the value in to be32.

Considering that diag_320_build_vce() already converts the value to be32, and feedback from V9 suggests that endianness is already accounted for, do we still need to convert it from be32 to CPU format?

https://lists.libreplanet.org/archive/html/qemu-s390x/2026-03/msg00162.html

Quoted 73 lines
Quoted 5 lines
target/s390x/diag.c +5 -0
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 545

Quoted 10 lines
target/s390x/diag.c +10 -0
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;

Same as here as we using vce->vce_hdr.len without conversion.

Quoted 53 lines
target/s390x/diag.c +33 -1
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;
#15 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 446 lines · Zhuoying Cai
Quoted 434 lines · Farhan Ali
Quoted 432 lines · Zhuoying Cai

DIAG 320 subcode 2 provides verification-certificates (VCs) that are in the certificate store. Only X509 certificates in DER format and SHA-256 hash type are recognized.

The subcode value is denoted by setting the second-left-most bit of an 8-byte field.

The Verification Certificate Block (VCB) contains the output data when the operation completes successfully. It includes a common header followed by zero or more Verification Certificate Entries (VCEs), depending on the VCB input length and the VC range (from the first VC index to the last VC index) in the certificate store.

Each VCE contains information about a certificate retrieved from the S390IPLCertificateStore, such as the certificate name, key type, key ID length, hash length, and the raw certificate data.
The key ID and hash are extracted from the raw certificate by the crypto API.

Note: SHA2-256 VC hash type is required for retrieving the hash (fingerprint) of the certificate.

---
  docs/specs/s390x-secure-ipl.rst |  24 +++
  include/hw/s390x/ipl/diag320.h  |  29 +++
  target/s390x/diag.c             | 339 +++++++++++++++++++++++++++++++-
  3 files changed, 391 insertions(+), 1 deletion(-)
docs/specs/s390x-secure-ipl.rst +24 -0
index 807a8ae393..d9c5c24ec7 100644
@@ -38,3 +38,27 @@ Subcode 1 - query verification certificate storage information
      The output is returned in the verification-certificate-storage-size block
      (VCSSB). A VCSSB length of 4 indicates that no certificates are available
      in the CS.
+
+Subcode 2 - store verification certificates
+    Provides VCs that are in the certificate store.
+
+    The output is provided in a VCB, which includes a common header followed by
+    zero or more verification-certificate entries (VCEs).
+
+    The instruction expects the cert store to maintain an origin of 1 for the
+    index (i.e. a retrieval of the first certificate in the store should be
+    denoted by setting first-VC to 1).
+
+    The first-VC and last-VC fields of the VCB specify the index range of
+    VCs to be stored in the VCB. Certs are stored sequentially, starting
+    with first-VC index. As each cert is stored, a "stored count" is
+    incremented. If there is not enough space to store all certs requested
+    by the index range, a "remaining count" will be recorded and no more
+    certificates will be stored.
+
+    Each VCE contains a header followed by information extracted from a
+    certificate within the certificate store. The information includes:
+    key-id, hash, and certificate data. This information is stored
+    contiguously in a VCE (with zero-padding). Following the header, the
+    key-id is immediately stored. The hash and certificate data follow and
+    may be accessed via the respective offset fields stored in the VCE.
include/hw/s390x/ipl/diag320.h +29 -0
index 90797728d8..35c652ff56 100644
@@ -12,19 +12,36 @@
 
  #define DIAG_320_SUBC_QUERY_ISM     0
  #define DIAG_320_SUBC_QUERY_VCSI    1
+#define DIAG_320_SUBC_STORE_VC      2
 
  #define DIAG_320_RC_OK              0x0001
  #define DIAG_320_RC_NOT_SUPPORTED   0x0102
  #define DIAG_320_RC_INVAL_VCSSB_LEN 0x0202
+#define DIAG_320_RC_INVAL_VCB_LEN   0x0204
+#define DIAG_320_RC_BAD_RANGE       0x0302
 
  #define DIAG_320_ISM_QUERY_SUBCODES 0x80000000
  #define DIAG_320_ISM_QUERY_VCSI     0x40000000
+#define DIAG_320_ISM_STORE_VC       0x20000000
 
  #define VCSSB_NO_VC     4
  #define VCSSB_MIN_LEN   128
 
  #define CERT_NAME_MAX_LEN  64
 
+/*
+ * If the VCE flags indicate an invalid certificate,
+ * the VCE length is set to 72, containing only the
+ * first five fields of VCEntry.
+ */
+#define VCE_INVALID_LEN 72
+
+#define DIAG_320_VCE_FLAGS_VALID                0x80
+#define DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING    0
+#define DIAG_320_VCE_KEYTYPE_ECDSA_P521         1
+#define DIAG_320_VCE_FORMAT_X509_DER            1
+#define DIAG_320_VCE_HASHTYPE_SHA2_256          1
+
  struct VCStorageSizeBlock {
      uint32_t length;
      uint8_t reserved0[3];
@@ -60,6 +77,12 @@ struct VCEntryHeader {
  };
  typedef struct VCEntryHeader VCEntryHeader;
 
+struct VCEntry {
+    VCEntryHeader vce_hdr;
+    uint8_t cert_buf[];
+};
+typedef struct VCEntry VCEntry;
+
  struct VCBlockHeader {
      uint32_t in_len;
      uint32_t reserved0;
@@ -74,4 +97,10 @@ struct VCBlockHeader {
  };
  typedef struct VCBlockHeader VCBlockHeader;
 
+struct VCBlock {
+    VCBlockHeader vcb_hdr;
+    uint8_t vce_buf[];
+};
+typedef struct VCBlock VCBlock;
+
  #endif
target/s390x/diag.c +285 -0
index f531ce9d82..0645fe39dc 100644
@@ -17,13 +17,16 @@
  #include "s390x-internal.h"
  #include "hw/watchdog/wdt_diag288.h"
  #include "system/cpus.h"
+#include "hw/s390x/cert-store.h"
  #include "hw/s390x/ipl.h"
  #include "hw/s390x/ipl/diag320.h"
  #include "hw/s390x/s390-virtio-ccw.h"
  #include "system/kvm.h"
  #include "kvm/kvm_s390x.h"
  #include "target/s390x/kvm/pv.h"
+#include "qapi/error.h"
  #include "qemu/error-report.h"
+#include "crypto/x509-utils.h"
 
 
  static inline bool diag_parm_addr_valid(uint64_t addr, size_t size, bool write)
@@ -238,8 +241,329 @@ static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1,
      return DIAG_320_RC_OK;
  }
 
+static bool is_cert_valid(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_cert_times(cert->raw, cert->size, &err);
+    if (rc != 0) {
+        error_report_err(err);
+        return false;
+    }
+
+    return true;
+}
+
+static int handle_key_id(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    int rc;
+    g_autofree unsigned char *key_id_data = NULL;
+    size_t key_id_len;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_get_cert_key_id(cert->raw, cert->size,
+                                      QCRYPTO_HASH_ALGO_SHA256,
+                                      &key_id_data, &key_id_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    if (sizeof(VCEntryHeader) + key_id_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write key ID: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.keyid_len = cpu_to_be16(key_id_len);
+
+    memcpy(vce->cert_buf, key_id_data, key_id_len);
+
+    return 0;
+}
+
+static int handle_hash(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t keyid_field_len)
+{
+    int rc;
+    uint16_t hash_offset;
+    g_autofree void *hash_data = NULL;
+    size_t hash_len;
+    Error *err = NULL;
+
+    hash_len = CERT_HASH_LEN;
+    hash_data = g_malloc0(hash_len);
+    rc = qcrypto_get_x509_cert_fingerprint(cert->raw, cert->size,
+                                           QCRYPTO_HASH_ALGO_SHA256,
+                                           hash_data, &hash_len, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    hash_offset = sizeof(VCEntryHeader) + keyid_field_len;
+    if (hash_offset + hash_len > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write hash: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.hash_len = cpu_to_be16(hash_len);
+    vce->vce_hdr.hash_type = DIAG_320_VCE_HASHTYPE_SHA2_256;
+    vce->vce_hdr.hash_offset = cpu_to_be16(hash_offset);
+
+    memcpy((uint8_t *)vce + hash_offset, hash_data, hash_len);
+
+    return 0;
+}
+
+static int handle_cert(VCEntry *vce, const S390IPLCertificate *cert,
+                       uint16_t hash_field_len)
+{
+    int rc;
+    uint16_t cert_offset;
+    g_autofree uint8_t *cert_der = NULL;
+    size_t der_size;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_convert_cert_der(cert->raw, cert->size,
+                                       &cert_der, &der_size, &err);
+    if (rc < 0) {
+        error_report_err(err);
+        return -1;
+    }
+
+    cert_offset = be16_to_cpu(vce->vce_hdr.hash_offset) + hash_field_len;
+    if (cert_offset + der_size > be32_to_cpu(vce->vce_hdr.len)) {
+        error_report("Unable to write certificate: exceeds buffer bounds");
+        return -1;
+    }
+
+    vce->vce_hdr.format = DIAG_320_VCE_FORMAT_X509_DER;
+    vce->vce_hdr.cert_len = cpu_to_be32(der_size);
+    vce->vce_hdr.cert_offset = cpu_to_be16(cert_offset);
+
+    memcpy((uint8_t *)vce + cert_offset, cert_der, der_size);
+
+    return 0;
+}
+
+static int get_key_type(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_ecc_curve_p521(cert->raw, cert->size, &err);
+    if (rc == -1) {
+        error_report_err(err);
+        return -1;
+    }
+
+    return (rc == 1) ? DIAG_320_VCE_KEYTYPE_ECDSA_P521 :
+                       DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING;
+}
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+
+static int build_vce_data(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    uint16_t keyid_field_len;
+    uint16_t hash_field_len;
+    uint32_t cert_field_len;
+    uint32_t vce_len;
+    int rc;
+
+    rc = handle_key_id(vce, cert);
+    if (rc) {
+        return -1;
+    }
+    keyid_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.keyid_len), 4);
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
Quoted 10 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 530

Quoted 5 lines
target/s390x/diag.c +5 -0
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {

I think we need to convert vce->vce_hdr.len from be32 to cpu? The diag_320_build_vce() will convert the value in to be32.

Quoted 6 lines

Considering that diag_320_build_vce() already converts the value to be32, and feedback from V9 suggests that endianness is already accounted for, do we still need to convert it from be32 to CPU format?

https://lists.libreplanet.org/archive/html/qemu-s390x/2026-03/msg00162.html

After thinking it through, I think we do need to convert from be32 to CPU format here because this value is used in calculations in native endianness format.

I had overlooked the fact that this code can run on architectures like x86/ARM when I removed be32_to_cpu() in V9.

Thanks for catching this! I'll fix it in the next version.

Quoted 74 lines
Quoted 73 lines
Quoted 5 lines
target/s390x/diag.c +5 -0
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 545

Quoted 10 lines
target/s390x/diag.c +10 -0
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;

Same as here as we using vce->vce_hdr.len without conversion.

Quoted 53 lines
target/s390x/diag.c +33 -1
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;
#16 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

In reply to Zhuoying Cai

On 5/5/26 16:18, Zhuoying Cai wrote:

[...]

include/hw/s390x/ipl/diag320.h line 43

Quoted 5 lines
include/hw/s390x/ipl/diag320.h +5 -0
+
+#define DIAG_320_VCE_FLAGS_VALID                0x80
+#define DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING    0
+#define DIAG_320_VCE_KEYTYPE_ECDSA_P521         1> +#define DIAG_320_VCE_FORMAT_X509_DER            1
+#define DIAG_320_VCE_HASHTYPE_SHA2_256          1

The key types, format, and hash types might be good as enumerations. It'd be especially helpful when going through the debugger and seeing explicit values printed out.

[...]

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 376

Quoted 13 lines
target/s390x/diag.c +13 -0
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }

Move the is_cert_valid check to here.

Quoted 5 lines
target/s390x/diag.c +5 -0
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+

[...]

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 515

Quoted 3 lines
target/s390x/diag.c +3 -0
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;

What about using g_autofree here and then removing the g_free's below?

Quoted 36 lines
target/s390x/diag.c +36 -0
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 561

Quoted 10 lines
target/s390x/diag.c +10 -0
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}

[...]

Aside from the endian conversion mentioned by Farhan, I think the rest of this patch looks good. I appreciate the inline comments. It has made coming back to these reviews a lot easier to understand your approach :)

Signature · 2 lines
Regards,
  Collin
#17 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

In reply to Zhuoying Cai
Quoted 39 lines · Zhuoying Cai

[...]

target/s390x/diag.c +37 -0
+}
+
+static int get_key_type(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_ecc_curve_p521(cert->raw, cert->size, &err);
+    if (rc == -1) {
+        error_report_err(err);
+        return -1;
+    }
+
+    return (rc == 1) ? DIAG_320_VCE_KEYTYPE_ECDSA_P521 :
+                       DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING;
+}
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+
+static int build_vce_data(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    uint16_t keyid_field_len;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 394

Quoted 10 lines
target/s390x/diag.c +10 -0
+    uint16_t hash_field_len;
+    uint32_t cert_field_len;
+    uint32_t vce_len;
+    int rc;
+
+    rc = handle_key_id(vce, cert);
+    if (rc) {
+        return -1;
+    }
+    keyid_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.keyid_len), 4);

Maybe return the converted length from the handle_* functions, with 0 being the error condition?

e.g. (untested)
    keyid_len = handle_key_id(vce, cert);
    if (!keyid_len) {
        return -1;
    }

Just a nit, but I think it would improve readability.

Quoted 7 lines
target/s390x/diag.c +7 -0
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 411

Quoted 10 lines
target/s390x/diag.c +10 -0
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }

We already used the maximum size when we allocated space for the VCE, so this check is redundant I think?

Quoted 15 lines
target/s390x/diag.c +15 -0
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 436

Quoted 10 lines
target/s390x/diag.c +10 -0
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);

In Patch 10, we define MAX_ENTRY_SIZE.  Is that something different than this? Let's use the constant here unless there is a specific reason not to.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 449

Quoted 13 lines
target/s390x/diag.c +13 -0
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);

It is not obvious later in the code if the VCE length is a true value or a place holder for the max size, so MAX_ENTRY_SIZE would help clarify also.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 457

Quoted 8 lines
target/s390x/diag.c +8 -0
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}

Actually, I wonder if we might be able to remove the diag_320_build_vce() function since it is basically just a wrapper for building the header and data.

If we introduce the MAX_ENTRY_SIZE constant and allocate memory before calling the build functions, I think we can simplify the whole thing.

See notes below in the loop to build VCEs...

Quoted 7 lines
target/s390x/diag.c +7 -0
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 474

Quoted 10 lines
target/s390x/diag.c +10 -0
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }

This is only the VCB header, right?  That's all the space is allocated for anyway.  I find it confusing, here is my understanding, please correct if wrong:

We are allocating a VCB and updating the header values, but we never populate the VCB's buffer area because each VCE being built has it's own malloc call?

Meaning when we read/write the VCB it is actually just the header, and the VCEs are written independently?

If that is correct, then we never really build a full VCB right? Could we just use the VCBHeader struct here instead to make that clear?

Quoted 31 lines
target/s390x/diag.c +31 -0
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 515

Quoted 10 lines
target/s390x/diag.c +10 -0
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;

What about g_autofree VCEntry *vce = g_malloc0(MAX_ENTRY_SIZE);

Collin already mentioned using g_autofree, but in addition to that if we can allocate the memory up front that would allow us to call the build functions directly from here e.g. (untested)

    if (build_vce_header(vce, cert, i) || build_vce_data(vce, cert) { vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
    }

That would avoid the frees and steal pointer too.

Quoted 73 lines
target/s390x/diag.c +56 -1
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }

target/s390x/diag.c void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra) · line 638

Quoted 10 lines
target/s390x/diag.c +7 -0
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;

Regards,
Jared Rossi

#18 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Thanks for the feedback!

Quoted 16 lines · Jared Rossi
Quoted 13 lines · Zhuoying Cai

[...]

target/s390x/diag.c +12 -0
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
Quoted 9 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 411

Quoted 5 lines
target/s390x/diag.c +5 -0
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }

We already used the maximum size when we allocated space for the VCE, so this
check is redundant I think?

Although exceeding the maximum size is unlikely, I think it’s good practice to keep this check, along with those in the handle_* functions. These checks help ensure that the actual lengths of the certificate metadata retrieved from the qcrypto functions remain within the defined limits.

Please let me know what you think.

Quoted 88 lines
Quoted 15 lines
target/s390x/diag.c +15 -0
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 436

Quoted 10 lines
target/s390x/diag.c +10 -0
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);

In Patch 10, we define MAX_ENTRY_SIZE.  Is that something different than this?
Let's use the constant here unless there is a specific reason not to.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 449

Quoted 13 lines
target/s390x/diag.c +13 -0
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);

It is not obvious later in the code if the VCE length is a true value or a place holder for the max size, so MAX_ENTRY_SIZE would help clarify also.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 457

Quoted 8 lines
target/s390x/diag.c +8 -0
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}

Actually, I wonder if we might be able to remove the diag_320_build_vce() function since it is basically just a wrapper for building the header and data.

If we introduce the MAX_ENTRY_SIZE constant and allocate memory before calling
the build functions, I think we can simplify the whole thing.

See notes below in the loop to build VCEs...

Quoted 7 lines
target/s390x/diag.c +7 -0
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 474

Quoted 10 lines
target/s390x/diag.c +10 -0
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }

This is only the VCB header, right?  That's all the space is allocated for anyway.  I find it confusing, here is my understanding, please correct if wrong:

We are allocating a VCB and updating the header values, but we never populate
the VCB's buffer area because each VCE being built has it's own malloc call?

Quoted 8 lines

Meaning when we read/write the VCB it is actually just the header, and the VCEs
are written independently?

If that is correct, then we never really build a full VCB right? Could we just
use the VCBHeader struct here instead to make that clear?

Yes, you're correct. We only build the VCB header here, and each VCE is allocated separately and appended after the header one by one.

I’ll update it to use the VCBHeader struct here to make that clearer.

Quoted 138 lines
Quoted 31 lines
target/s390x/diag.c +31 -0
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 515

Quoted 10 lines
target/s390x/diag.c +10 -0
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;

What about g_autofree VCEntry *vce = g_malloc0(MAX_ENTRY_SIZE);

Collin already mentioned using g_autofree, but in addition to that if we can allocate the memory up front that would allow us to call the build functions directly from here e.g. (untested)

    if (build_vce_header(vce, cert, i) || build_vce_data(vce, cert) { vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
    }

That would avoid the frees and steal pointer too.

Quoted 73 lines
target/s390x/diag.c +56 -1
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }

target/s390x/diag.c void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra) · line 638

Quoted 10 lines
target/s390x/diag.c +7 -0
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;

Regards,
Jared Rossi

#19 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 27 lines · Zhuoying Cai

Thanks for the feedback!

Quoted 15 lines · Jared Rossi
Quoted 13 lines · Zhuoying Cai

[...]

target/s390x/diag.c +12 -0
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
Quoted 9 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 411

Quoted 5 lines
target/s390x/diag.c +5 -0
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }

We already used the maximum size when we allocated space for the VCE, so this
check is redundant I think?

Quoted 7 lines

Although exceeding the maximum size is unlikely, I think it’s good practice to keep this check, along with those in the handle_* functions. These checks help ensure that the actual lengths of the certificate metadata retrieved from the qcrypto functions remain within the defined limits.

Please let me know what you think.

After taking another look, I realize this check is not redundant in the way I thought it was.  As far as I can tell, when building the cert store, the size of each entry is checked using the largest_cert_size variable, but we never validate that this value is within our max cert size.  So the check here is actually the first time we validate the total size.

In my opinion we should check this in the update_cert_store() function that was introduced in Patch 4 and gets called as the cert store is populated.  I guess this ties back in to some of the other comments about defining MAX_ENTRY_SIZE earlier in the series.

Maybe we could detect invalid certs earlier if we add a secondary check that data_buf_size <= CERT_BUF_MAX_LEN when updating largest_cert_size.  I think both update_cert_store() and build_vce_data() are doing the same size calculations, right?

I think we have all of this information available to reject certs before they are added to the cert store.

Regards,
Jared Rossi

#20 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 60 lines · Jared Rossi
Quoted 27 lines · Zhuoying Cai

Thanks for the feedback!

Quoted 15 lines · Jared Rossi
Quoted 13 lines · Zhuoying Cai

[...]

target/s390x/diag.c +12 -0
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
Quoted 9 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 411

Quoted 5 lines
target/s390x/diag.c +5 -0
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }

We already used the maximum size when we allocated space for the VCE, so this
check is redundant I think?

Quoted 7 lines

Although exceeding the maximum size is unlikely, I think it’s good practice to keep this check, along with those in the handle_* functions. These checks help ensure that the actual lengths of the certificate metadata retrieved from the qcrypto functions remain within the defined limits.

Please let me know what you think.

After taking another look, I realize this check is not redundant in the way I
thought it was.  As far as I can tell, when building the cert store, the size
of each entry is checked using the largest_cert_size variable, but we never validate that this value is within our max cert size.  So the check here is actually the first time we validate the total size.

In my opinion we should check this in the update_cert_store() function that was
introduced in Patch 4 and gets called as the cert store is populated.  I guess
this ties back in to some of the other comments about defining MAX_ENTRY_SIZE
earlier in the series.

Maybe we could detect invalid certs earlier if we add a secondary check that data_buf_size <= CERT_BUF_MAX_LEN when updating largest_cert_size.  I think both
update_cert_store() and build_vce_data() are doing the same size calculations,
right?

Quoted 6 lines

I think we have all of this information available to reject certs before they
are added to the cert store.

Regards,
Jared Rossi

Thanks for taking another look.

The current version I’m working on defines MAX_ENTRY_SIZE in the current patch (s390x/diag: Implement DIAG 320 subcode 2), since that’s where it is used. In the next patch (hw/s390x: Define maximum certificate buffer length), I define CERT_BUF_MAX_LEN (MAX_ENTRY_SIZE - sizeof(VCEntryHeader)) and add a data_buf_size <= CERT_BUF_MAX_LEN check before updating largest_cert_size in update_cert_store().

update_cert_store() uses expected size values, whereas build_vce_data() uses actual size values, but these should match. With the CERT_BUF_MAX_LEN check in update_cert_store(), invalid certs would be rejected before being added to the cert store.

I thought it might still be good practice to keep both checks to ensure the size from build_vce_data() stays within bounds, but I may have overthought that.

If you think the check in build_vce_data() is redundant once we add the validation in update_cert_store(), I can remove it. Should I also remove the checks in the handle_* functions as well?

#21 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

In reply to Jared Rossi
Quoted 215 lines · Jared Rossi
Quoted 39 lines · Zhuoying Cai

[...]

target/s390x/diag.c +37 -0
+}
+
+static int get_key_type(const S390IPLCertificate *cert)
+{
+    int rc;
+    Error *err = NULL;
+
+    rc = qcrypto_x509_check_ecc_curve_p521(cert->raw, cert->size, &err);
+    if (rc == -1) {
+        error_report_err(err);
+        return -1;
+    }
+
+    return (rc == 1) ? DIAG_320_VCE_KEYTYPE_ECDSA_P521 :
+                       DIAG_320_VCE_KEYTYPE_SELF_DESCRIBING;
+}
+
+static int build_vce_header(VCEntry *vce, const S390IPLCertificate *cert, int idx)
+{
+    int key_type;
+
+    vce->vce_hdr.len = cpu_to_be32(sizeof(VCEntryHeader));
+    vce->vce_hdr.cert_idx = cpu_to_be16(idx + 1);
+    memcpy(vce->vce_hdr.name, cert->name, CERT_NAME_MAX_LEN);
+
+    key_type = get_key_type(cert);
+    if (key_type == -1) {
+        return -1;
+    }
+    vce->vce_hdr.key_type = key_type;
+
+    return 0;
+}
+
+static int build_vce_data(VCEntry *vce, const S390IPLCertificate *cert)
+{
+    uint16_t keyid_field_len;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 394

Quoted 10 lines
target/s390x/diag.c +10 -0
+    uint16_t hash_field_len;
+    uint32_t cert_field_len;
+    uint32_t vce_len;
+    int rc;
+
+    rc = handle_key_id(vce, cert);
+    if (rc) {
+        return -1;
+    }
+    keyid_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.keyid_len), 4);

Maybe return the converted length from the handle_* functions, with 0 being the
error condition?

e.g. (untested)
    keyid_len = handle_key_id(vce, cert);
    if (!keyid_len) {
        return -1;
    }

Just a nit, but I think it would improve readability.

Quoted 7 lines
target/s390x/diag.c +7 -0
+
+    rc = handle_hash(vce, cert, keyid_field_len);
+    if (rc) {
+        return -1;
+    }
+    hash_field_len = ROUND_UP(be16_to_cpu(vce->vce_hdr.hash_len), 4);
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 411

Quoted 10 lines
target/s390x/diag.c +10 -0
+    rc = handle_cert(vce, cert, hash_field_len);
+    if (rc || !is_cert_valid(cert)) {
+        return -1;
+    }
+    cert_field_len = ROUND_UP(be32_to_cpu(vce->vce_hdr.cert_len), 4);
+
+    vce_len = sizeof(VCEntryHeader) + keyid_field_len + hash_field_len + cert_field_len;
+    if (vce_len > be32_to_cpu(vce->vce_hdr.len)) {
+        return -1;
+    }

We already used the maximum size when we allocated space for the VCE, so this
check is redundant I think?

Quoted 15 lines
target/s390x/diag.c +15 -0
+
+    vce->vce_hdr.flags |= DIAG_320_VCE_FLAGS_VALID;
+
+    /* Update vce length to reflect the actual size used by vce */
+    vce->vce_hdr.len = cpu_to_be32(vce_len);
+
+    return 0;
+}
+
+static VCEntry *diag_320_build_vce(const S390IPLCertificate *cert, int idx)
+{
+    g_autofree VCEntry *vce = NULL;
+    uint32_t vce_max_size;
+    int rc;
+

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 436

Quoted 10 lines
target/s390x/diag.c +10 -0
+    /*
+     * Each field of the VCE is word-aligned.
+     * Allocate enough space for the largest possible size for this VCE.
+     * As the certificate fields (key-id, hash, data) are parsed, the
+     * VCE's length field will be updated accordingly.
+     */
+    vce_max_size = sizeof(VCEntryHeader) +
+                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
+                   ROUND_UP(CERT_HASH_LEN, 4) +
+                   ROUND_UP(cert->der_size, 4);

In Patch 10, we define MAX_ENTRY_SIZE.  Is that something different than this?
Let's use the constant here unless there is a specific reason not to.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 449

Quoted 13 lines
target/s390x/diag.c +13 -0
+
+    vce = g_malloc0(vce_max_size);
+    rc = build_vce_header(vce, cert, idx);
+    if (rc) {
+        /*
+         * Error occurs - VCE does not contain a valid certificate.
+         * Bit 0 of the VCE flags is 0 and the VCE length is set.
+         */
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+        goto out;
+    }
+
+    vce->vce_hdr.len = cpu_to_be32(vce_max_size);

It is not obvious later in the code if the VCE length is a true value or a place holder for the max size, so MAX_ENTRY_SIZE would help clarify also.

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 457

Quoted 8 lines
target/s390x/diag.c +8 -0
+    rc = build_vce_data(vce, cert);
+    if (rc) {
+        vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
+    }
+
+out:
+    return g_steal_pointer(&vce);
+}

Actually, I wonder if we might be able to remove the diag_320_build_vce() function since it is basically just a wrapper for building the header and data.

If we introduce the MAX_ENTRY_SIZE constant and allocate memory before calling
the build functions, I think we can simplify the whole thing.

See notes below in the loop to build VCEs...

Quoted 7 lines
target/s390x/diag.c +7 -0
+
+static int handle_diag320_store_vc(S390CPU *cpu, uint64_t addr, uint64_t r1, uintptr_t ra,
+                                   S390IPLCertificateStore *cs)
+{
+    g_autofree VCBlock *vcb = NULL;
+    size_t remaining_space;
+    uint16_t first_vc_index;

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 474

Quoted 10 lines
target/s390x/diag.c +10 -0
+    uint16_t last_vc_index;
+    int cs_start_index;
+    int cs_end_index;
+    uint32_t in_len;
+
+    vcb = g_new0(VCBlock, 1);
+    if (s390_cpu_virt_mem_read(cpu, addr, r1, vcb, sizeof(*vcb))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }

This is only the VCB header, right?  That's all the space is allocated for anyway.  I find it confusing, here is my understanding, please correct if wrong:

We are allocating a VCB and updating the header values, but we never populate
the VCB's buffer area because each VCE being built has it's own malloc call?

Meaning when we read/write the VCB it is actually just the header, and the VCEs
are written independently?

If that is correct, then we never really build a full VCB right? Could we just
use the VCBHeader struct here instead to make that clear?

Quoted 34 lines
target/s390x/diag.c +34 -0
+
+    in_len = be32_to_cpu(vcb->vcb_hdr.in_len);
+    first_vc_index = be16_to_cpu(vcb->vcb_hdr.first_vc_index);
+    last_vc_index = be16_to_cpu(vcb->vcb_hdr.last_vc_index);
+
+    if (in_len % TARGET_PAGE_SIZE != 0) {
+        return DIAG_320_RC_INVAL_VCB_LEN;
+    }
+
+    if (first_vc_index > last_vc_index) {
+        return DIAG_320_RC_BAD_RANGE;
+    }
+
+    vcb->vcb_hdr.out_len = sizeof(VCBlockHeader);
+
+    /*
+     * DIAG 320 subcode 2 expects to query a certificate store that
+     * maintains an index origin of 1. However, the S390IPLCertificateStore
+     * maintains an index origin of 0. Thus, the indices must be adjusted
+     * for correct access into the cert store. A couple of special cases
+     * must also be accounted for.
+     */
+
+    /* Both indices are 0; return header with no certs */
+    if (first_vc_index == 0 && last_vc_index == 0) {
+        goto out;
+    }
+
+    /* Normalize indices */
+    cs_start_index = (first_vc_index == 0) ? 0 : first_vc_index - 1;
+    cs_end_index = last_vc_index - 1;
+
+    /* Requested range is outside the cert store; return header with no certs */
+    if (cs_start_index >= cs->count || cs_end_index >= cs->count) {
Quoted 9 lines

target/s390x/diag.c static int handle_diag320_query_vcsi(S390CPU *cpu, uint64_t addr, uint64_t r1, · line 515

Quoted 7 lines
target/s390x/diag.c +7 -0
+        goto out;
+    }
+
+    remaining_space = in_len - sizeof(VCBlockHeader);
+
+    for (int i = cs_start_index; i <= cs_end_index; i++) {
+        VCEntry *vce;

What about g_autofree VCEntry *vce = g_malloc0(MAX_ENTRY_SIZE);

    vce_max_size = sizeof(VCEntryHeader) +
                   ROUND_UP(CERT_KEY_ID_LEN, 4) +
                   ROUND_UP(CERT_HASH_LEN, 4) +
                   ROUND_UP(cert->der_size, 4);

After thinking about this, I’m not entirely sure, but I think using the calculated vce_max_size might be a better choice than MAX_ENTRY_SIZE, since vce_max_size more closely reflects the size of the current VCE.

MAX_ENTRY_SIZE is currently defined as 8192, which is significantly larger than the size of a single VCB that will be requested in a later patch. Although we check whether the remaining space is sufficient to store the VCE, allocating MAX_ENTRY_SIZE for each VCE might be unnecessary?

Just wondering if this makes sense, or if you think we should keep using MAX_ENTRY_SIZE here?

Quoted 95 lines

Collin already mentioned using g_autofree, but in addition to that if we can allocate the memory up front that would allow us to call the build functions directly from here e.g. (untested)

    if (build_vce_header(vce, cert, i) || build_vce_data(vce, cert) { vce->vce_hdr.len = cpu_to_be32(VCE_INVALID_LEN);
    }

That would avoid the frees and steal pointer too.

Quoted 73 lines
target/s390x/diag.c +56 -1
+        const S390IPLCertificate *cert = &cs->certs[i];
+
+        /*
+         * Bit 0 of the VCE flags indicates whether the certificate is valid.
+         * The caller of DIAG320 subcode 2 is responsible for verifying that
+         * the VCE contains a valid certificate.
+         */
+        vce = diag_320_build_vce(cert, i);
+
+        /*
+         * If there is no more space to store the cert,
+         * set the remaining verification cert count and
+         * break early.
+         */
+        if (remaining_space < vce->vce_hdr.len) {
+            vcb->vcb_hdr.remain_ct = cpu_to_be16(last_vc_index - i);
+            g_free(vce);
+            break;
+        }
+
+        /* Write VCE */
+        if (s390_cpu_virt_mem_write(cpu, addr + vcb->vcb_hdr.out_len, r1,
+                                    vce, vce->vce_hdr.len)) {
+            s390_cpu_virt_mem_handle_exc(cpu, ra);
+            g_free(vce);
+            return -1;
+        }
+
+        vcb->vcb_hdr.out_len += vce->vce_hdr.len;
+        remaining_space -= vce->vce_hdr.len;
+        vcb->vcb_hdr.stored_ct++;
+
+        g_free(vce);
+    }
+    vcb->vcb_hdr.stored_ct = cpu_to_be16(vcb->vcb_hdr.stored_ct);
+
+out:
+    vcb->vcb_hdr.out_len = cpu_to_be32(vcb->vcb_hdr.out_len);
+
+    if (s390_cpu_virt_mem_write(cpu, addr, r1, vcb, sizeof(VCBlockHeader))) {
+        s390_cpu_virt_mem_handle_exc(cpu, ra);
+        return -1;
+    }
+
+    return DIAG_320_RC_OK;
+}
+
  QEMU_BUILD_BUG_MSG(sizeof(VCStorageSizeBlock) != VCSSB_MIN_LEN,
                     "size of VCStorageSizeBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCBlock) != 64, "size of VCBlock is wrong");
+QEMU_BUILD_BUG_MSG(sizeof(VCEntry) != 128, "size of VCEntry is wrong");
 
  void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
  {
@@ -270,7 +594,8 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
           * for now.
           */
          uint32_t ism_word0 = cpu_to_be32(DIAG_320_ISM_QUERY_SUBCODES |
-                                         DIAG_320_ISM_QUERY_VCSI);
+                                         DIAG_320_ISM_QUERY_VCSI |
+                                         DIAG_320_ISM_STORE_VC);
 
          if (s390_cpu_virt_mem_write(cpu, addr, r1, &ism_word0, sizeof(ism_word0))) {
              s390_cpu_virt_mem_handle_exc(cpu, ra);
@@ -296,6 +621,18 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
          }
          env->regs[r1 + 1] = rc;
          break;
+    case DIAG_320_SUBC_STORE_VC:
+        if (addr & ~TARGET_PAGE_MASK) {
+            s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+            return;
+        }

target/s390x/diag.c void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra) · line 638

Quoted 10 lines
target/s390x/diag.c +7 -0
+
+        rc = handle_diag320_store_vc(cpu, addr, r1, ra, cs);
+        if (rc == -1) {
+            return;
+        }
+        env->regs[r1 + 1] = rc;
+        break;
      default:
          env->regs[r1 + 1] = DIAG_320_RC_NOT_SUPPORTED;
          break;

Regards,
Jared Rossi

#22 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 7 lines · Zhuoying Cai

[...]

     vce_max_size = sizeof(VCEntryHeader) +
                    ROUND_UP(CERT_KEY_ID_LEN, 4) +
                    ROUND_UP(CERT_HASH_LEN, 4) +
                    ROUND_UP(cert->der_size, 4);
Quoted 7 lines

After thinking about this, I’m not entirely sure, but I think using the calculated vce_max_size might be a better choice than MAX_ENTRY_SIZE, since vce_max_size more closely reflects the size of the current VCE.

MAX_ENTRY_SIZE is currently defined as 8192, which is significantly larger than the size of a single VCB that will be requested in a later patch.

I agree that it does make more sense to use the calculated size here, but do we actually know 8192 is significantly larger than what we will need? If so that seems like a problem with our definition of the max size.

Can we use a smaller value, or is it possible that the calculated vce_max_size is close to 8k anyway?

Quoted 5 lines

Although we check whether the remaining space is sufficient to store the VCE, allocating MAX_ENTRY_SIZE for each VCE might be unnecessary?

Just wondering if this makes sense, or if you think we should keep using MAX_ENTRY_SIZE here?

In this context, yes, it would be better to use the calculated size, but also if you feel that the current definition of MAX_ENTRY_SIZE will be significantly larger than we need, should we reconsider what we define MAX_ENTRY_SIZE as?

Quoted 1 line

[...]

Regards,
Jared Rossi

#23 lore raw

Re: [PATCH v11 09/32] s390x/diag: Implement DIAG 320 subcode 2

Quoted 18 lines · Jared Rossi
Quoted 7 lines · Zhuoying Cai

[...]

     vce_max_size = sizeof(VCEntryHeader) +
                    ROUND_UP(CERT_KEY_ID_LEN, 4) +
                    ROUND_UP(CERT_HASH_LEN, 4) +
                    ROUND_UP(cert->der_size, 4);
Quoted 7 lines

After thinking about this, I’m not entirely sure, but I think using the calculated vce_max_size might be a better choice than MAX_ENTRY_SIZE, since vce_max_size more closely reflects the size of the current VCE.

MAX_ENTRY_SIZE is currently defined as 8192, which is significantly larger than the size of a single VCB that will be requested in a later patch.

Quoted 7 lines

I agree that it does make more sense to use the calculated size here, but do we actually know 8192 is significantly larger than what we will need? If so that seems like a problem with our definition of the max size.

Can we use a smaller value, or is it possible that the calculated vce_max_size is close to 8k anyway?

I'm not entirely sure, but I think it’s uncommon for a self-generated certificate to reach such a large size, though it is not impossible. From my experience, the largest certificate I’ve generated used an RSA 16384-bit key and was 5982 bytes. Typically, certificates range from about 1 KB to 4 KB in size. For reference, RHEL 10.2 signs components using the Red Hat Secure Boot 302 certificate from
https://access.redhat.com/security/team/key, which has a size of 4429 bytes.

Quoted 9 lines
Quoted 5 lines

Although we check whether the remaining space is sufficient to store the VCE, allocating MAX_ENTRY_SIZE for each VCE might be unnecessary?

Just wondering if this makes sense, or if you think we should keep using MAX_ENTRY_SIZE here?

In this context, yes, it would be better to use the calculated size, but also if you feel that the current definition of MAX_ENTRY_SIZE will be significantly larger than we need, should we reconsider what we define MAX_ENTRY_SIZE as?

We could reduce the limit to something like 6144 (6 * 1024) or 7168 (7 * 1024) to better align with the certificate sizes we are likely to use during verification, or keep it at 8192 (8 * 1024) to provide additional buffer for less common cases.

Please let me know what you think.

Quoted 4 lines
Quoted 1 line

[...]

Regards,
Jared Rossi

#24 lore raw

PATCH v11 10/32 hw/s390x: Define finite size for single entry VCEntry

In reply to Zhuoying Cai

Define MAX_ENTRY_SIZE (8KB) and CERT_BUF_MAX_LEN to establish a finite size for a single entry VCEntry. Add validation in update_cert_store() to ensure certificate data does not exceed this limit.

This finite size definition is needed for proper memory allocation and will be used in a later commit to handle VCEntry structures with known size constraints.

---
 hw/s390x/cert-store.c          | 15 +++++++++++++--
 include/hw/s390x/ipl/diag320.h |  3 +++
 2 files changed, 16 insertions(+), 2 deletions(-)
hw/s390x/cert-store.c +13 -2
index a4f15627e9..221267781b 100644
@@ -73,7 +73,7 @@ static S390IPLCertificate *init_cert(char *path, Error **errp)
     return cert;
 }
 
-static void update_cert_store(S390IPLCertificateStore *cert_store,
+static int update_cert_store(S390IPLCertificateStore *cert_store,
                               S390IPLCertificate *cert)
 {
     size_t data_buf_size;
@@ -87,6 +87,12 @@ static void update_cert_store(S390IPLCertificateStore *cert_store,
     cert_buf_size = ROUND_UP(cert->der_size, 4);
     data_buf_size = keyid_buf_size + hash_buf_size + cert_buf_size;
 
+    if (data_buf_size > CERT_BUF_MAX_LEN) {
+        error_report("Certificate data size %zu exceeds maximum buffer size %ld",
+                     data_buf_size, CERT_BUF_MAX_LEN);
+        return -1;
+    }
+
     if (cert_store->largest_cert_size < data_buf_size) {
         cert_store->largest_cert_size = data_buf_size;
     }
@@ -96,6 +102,8 @@ static void update_cert_store(S390IPLCertificateStore *cert_store,
     cert_store->certs[cert_store->count] = *cert;
     cert_store->total_bytes += data_buf_size;
     cert_store->count++;
+
+    return 0;
 }
 
 static GPtrArray *get_cert_paths(Error **errp)
@@ -214,7 +222,10 @@ void s390_ipl_create_cert_store(S390IPLCertificateStore *cert_store)
             exit(1);
         }
 
-        update_cert_store(cert_store, cert);
+        if (update_cert_store(cert_store, cert)) {
+            g_ptr_array_free(cert_path_builder, TRUE);
+            exit(1);
+        }
     }
 
     g_ptr_array_free(cert_path_builder, TRUE);
include/hw/s390x/ipl/diag320.h +3 -0
index 35c652ff56..75065d2fe4 100644
@@ -83,6 +83,9 @@ struct VCEntry {
 };
 typedef struct VCEntry VCEntry;
 
+#define MAX_ENTRY_SIZE      (8 * 1024)
+#define CERT_BUF_MAX_LEN    (MAX_ENTRY_SIZE - sizeof(VCEntryHeader))
+
 struct VCBlockHeader {
     uint32_t in_len;
     uint32_t reserved0;
Signature · 1 line
2.54.0
#25 lore raw

Re: [PATCH v11 10/32] hw/s390x: Define finite size for single entry VCEntry

Quoted 19 lines · Zhuoying Cai

Define MAX_ENTRY_SIZE (8KB) and CERT_BUF_MAX_LEN to establish a finite size for a single entry VCEntry. Add validation in update_cert_store() to ensure certificate data does not exceed this limit.

This finite size definition is needed for proper memory allocation and will be used in a later commit to handle VCEntry structures with known size constraints.

---
 hw/s390x/cert-store.c          | 15 +++++++++++++--
 include/hw/s390x/ipl/diag320.h |  3 +++
 2 files changed, 16 insertions(+), 2 deletions(-)
hw/s390x/cert-store.c +0 -0
index a4f15627e9..221267781b 100644

hw/s390x/cert-store.c static S390IPLCertificate *init_cert(char *path, Error **errp) · line 77

Quoted 6 lines
hw/s390x/cert-store.c +1 -1
@@ -73,7 +73,7 @@ static S390IPLCertificate *init_cert(char *path, Error **errp)
     return cert;
 }
 
-static void update_cert_store(S390IPLCertificateStore *cert_store,
+static int update_cert_store(S390IPLCertificateStore *cert_store,
                               S390IPLCertificate *cert)

In patch 4, you can define this function as an int type in anticipation of these changes, and where you call the g_assert() for cert count, change that to an if (check) return -1.

The if (update_cert_store(...) { ... } code should also go in patch 4.

This will make this patch much more streamlined, where only the #defines and the new check in update_cert_store is introduced.

Quoted 41 lines
hw/s390x/cert-store.c +12 -1
 {
     size_t data_buf_size;
@@ -87,6 +87,12 @@ static void update_cert_store(S390IPLCertificateStore *cert_store,
     cert_buf_size = ROUND_UP(cert->der_size, 4);
     data_buf_size = keyid_buf_size + hash_buf_size + cert_buf_size;
 
+    if (data_buf_size > CERT_BUF_MAX_LEN) {
+        error_report("Certificate data size %zu exceeds maximum buffer size %ld",
+                     data_buf_size, CERT_BUF_MAX_LEN);
+        return -1;
+    }
+
     if (cert_store->largest_cert_size < data_buf_size) {
         cert_store->largest_cert_size = data_buf_size;
     }
@@ -96,6 +102,8 @@ static void update_cert_store(S390IPLCertificateStore *cert_store,
     cert_store->certs[cert_store->count] = *cert;
     cert_store->total_bytes += data_buf_size;
     cert_store->count++;
+
+    return 0;
 }
 
 static GPtrArray *get_cert_paths(Error **errp)
@@ -214,7 +222,10 @@ void s390_ipl_create_cert_store(S390IPLCertificateStore *cert_store)
             exit(1);
         }
 
-        update_cert_store(cert_store, cert);
+        if (update_cert_store(cert_store, cert)) {
+            g_ptr_array_free(cert_path_builder, TRUE);
+            exit(1);
+        }
     }
 
     g_ptr_array_free(cert_path_builder, TRUE);
include/hw/s390x/ipl/diag320.h +0 -0
index 35c652ff56..75065d2fe4 100644

include/hw/s390x/ipl/diag320.h struct VCEntry { · line 86

Quoted 4 lines
include/hw/s390x/ipl/diag320.h +1 -0
@@ -83,6 +83,9 @@ struct VCEntry {
 };
 typedef struct VCEntry VCEntry;
 
+#define MAX_ENTRY_SIZE      (8 * 1024)

s/MAX_ENTRY_SIZE/MAX_VCENTRY_SIZE ?

Quoted 5 lines
include/hw/s390x/ipl/diag320.h +2 -0
+#define CERT_BUF_MAX_LEN    (MAX_ENTRY_SIZE - sizeof(VCEntryHeader))
+
 struct VCBlockHeader {
     uint32_t in_len;
     uint32_t reserved0;
Signature · 2 lines
Regards,
  Collin
#26 lore raw

PATCH v11 11/32 s390x/diag: Introduce DIAG 508 for secure IPL operations

In reply to Zhuoying Cai

From: Collin Walling <[email protected]>

In order to support secure IPL (aka secure boot) for the s390-ccw BIOS, a new s390 DIAGNOSE instruction is introduced to leverage QEMU for handling operations such as signature verification and certificate retrieval.

Currently, only subcode 0 is supported with this patch, which is used to query a bitmap of which subcodes are supported.

---
 docs/specs/s390x-secure-ipl.rst | 18 ++++++++++++++++++
 include/hw/s390x/ipl/diag508.h  | 15 +++++++++++++++
 target/s390x/diag.c             | 27 +++++++++++++++++++++++++++
 target/s390x/kvm/kvm.c          | 14 ++++++++++++++
 target/s390x/s390x-internal.h   |  2 ++
 target/s390x/tcg/misc_helper.c  |  7 +++++++
 6 files changed, 83 insertions(+)
 create mode 100644 include/hw/s390x/ipl/diag508.h
docs/specs/s390x-secure-ipl.rst +18 -0
index d9c5c24ec7..488981339d 100644
@@ -62,3 +62,21 @@ Subcode 2 - store verification certificates
     contiguously in a VCE (with zero-padding). Following the header, the
     key-id is immediately stored. The hash and certificate data follow and
     may be accessed via the respective offset fields stored in the VCE.
+
+
+Secure IPL Data Structures, Facilities, and Functions
+-----------------------------------------------------
+
+DIAGNOSE function code 'X'508' - IPL extensions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+DIAGNOSE 'X'508' is reserved for guest use in order to facilitate communication
+of additional IPL operations that cannot be handled by guest code, such as
+signature verification for secure IPL.
+
+If the function code specifies 0x508, IPL extension functions are performed.
+These functions are meant to provide extended functionality for s390 guest boot
+that requires assistance from QEMU.
+
+Subcode 0 - query installed subcodes
+    Returns a 64-bit mask indicating which subcodes are supported.
include/hw/s390x/ipl/diag508.h new file +15 -0
new file mode 100644
index 0000000000..6281ad8299
@@ -0,0 +1,15 @@
+/*
+ * S/390 DIAGNOSE 508 definitions and structures
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Collin Walling <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef S390X_DIAG508_H
+#define S390X_DIAG508_H
+
+#define DIAG_508_SUBC_QUERY_SUBC    0x0000
+
+#endif
target/s390x/diag.c +27 -0
index 0645fe39dc..390a543ede 100644
@@ -20,6 +20,7 @@
 #include "hw/s390x/cert-store.h"
 #include "hw/s390x/ipl.h"
 #include "hw/s390x/ipl/diag320.h"
+#include "hw/s390x/ipl/diag508.h"
 #include "hw/s390x/s390-virtio-ccw.h"
 #include "system/kvm.h"
 #include "kvm/kvm_s390x.h"
@@ -638,3 +639,29 @@ void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
         break;
     }
 }
+
+void handle_diag_508(CPUS390XState *env, uint64_t r1, uint64_t r3, uintptr_t ra)
+{
+    uint64_t subcode = env->regs[r3];
+    int rc;
+
+    if (env->psw.mask & PSW_MASK_PSTATE) {
+        s390_program_interrupt(env, PGM_PRIVILEGED, ra);
+        return;
+    }
+
+    if ((subcode & ~0x0ffffULL) || (r1 & 1)) {
+        s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+        return;
+    }
+
+    switch (subcode) {
+    case DIAG_508_SUBC_QUERY_SUBC:
+        rc = 0;
+        break;
+    default:
+        s390_program_interrupt(env, PGM_SPECIFICATION, ra);
+        return;
+    }
+    env->regs[r1 + 1] = rc;
+}
target/s390x/kvm/kvm.c +14 -0
index a5411859a8..82f7fed9ec 100644
@@ -102,6 +102,7 @@
 #define DIAG_CERT_STORE                 0x320
 #define DIAG_KVM_HYPERCALL              0x500
 #define DIAG_KVM_BREAKPOINT             0x501
+#define DIAG_SECURE_IPL                 0x508
 
 #define ICPT_INSTRUCTION                0x04
 #define ICPT_PROGRAM                    0x08
@@ -1542,6 +1543,16 @@ static void kvm_handle_diag_320(S390CPU *cpu, struct kvm_run *run)
     handle_diag_320(&cpu->env, r1, r3, RA_IGNORED);
 }
 
+static void kvm_handle_diag_508(S390CPU *cpu, struct kvm_run *run)
+{
+    uint64_t r1, r3;
+
+    r1 = (run->s390_sieic.ipa & 0x00f0) >> 4;
+    r3 = run->s390_sieic.ipa & 0x000f;
+
+    handle_diag_508(&cpu->env, r1, r3, RA_IGNORED);
+}
+
 #define DIAG_KVM_CODE_MASK 0x000000000000ffff
 
 static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
@@ -1575,6 +1586,9 @@ static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)
     case DIAG_CERT_STORE:
         kvm_handle_diag_320(cpu, run);
         break;
+    case DIAG_SECURE_IPL:
+        kvm_handle_diag_508(cpu, run);
+        break;
     default:
         trace_kvm_insn_diag(func_code);
         kvm_s390_program_interrupt(cpu, PGM_SPECIFICATION);
target/s390x/s390x-internal.h +2 -0
index b16490bce6..367df65970 100644
@@ -390,6 +390,8 @@ void handle_diag_308(CPUS390XState *env, uint64_t r1, uint64_t r3,
                      uintptr_t ra);
 void handle_diag_320(CPUS390XState *env, uint64_t r1, uint64_t r3,
                      uintptr_t ra);
+void handle_diag_508(CPUS390XState *env, uint64_t r1, uint64_t r3,
+                     uintptr_t ra);
 
 
 /* translate.c */
target/s390x/tcg/misc_helper.c +7 -0
index 4d73475d95..562dde9cb3 100644
@@ -149,6 +149,13 @@ void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num)
         bql_unlock();
         r = 0;
         break;
+    case 0x508:
+        /* secure ipl operations */
+        bql_lock();
+        handle_diag_508(env, r1, r3, GETPC());
+        bql_unlock();
+        r = 0;
+        break;
     default:
         r = -1;
         break;
Signature · 1 line
2.54.0
#27 lore raw

PATCH v11 12/32 crypto/x509-utils: Add helper functions for DIAG 508 subcode 1

In reply to Zhuoying Cai

Introduce helper functions to support signature verification required by DIAG 508 subcode 1:

qcrypto_pkcs7_convert_sig_pem() – converts a signature from DER to PEM format qcrypto_x509_verify_sig() – verifies the provided data against the given signature

These functions enable basic signature verification support.

---
 crypto/x509-utils.c         | 108 ++++++++++++++++++++++++++++++++++++
 include/crypto/x509-utils.h |  41 ++++++++++++++
 2 files changed, 149 insertions(+)
crypto/x509-utils.c +108 -0
index 7dd8d1a0e9..738f3c95af 100644
@@ -16,6 +16,7 @@
 #include <gnutls/gnutls.h>
 #include <gnutls/crypto.h>
 #include <gnutls/x509.h>
+#include <gnutls/pkcs7.h>
 
 static const int qcrypto_to_gnutls_hash_alg_map[QCRYPTO_HASH_ALGO__MAX] = {
     [QCRYPTO_HASH_ALGO_MD5] = GNUTLS_DIG_MD5,
@@ -335,6 +336,96 @@ int qcrypto_x509_check_ecc_curve_p521(uint8_t *cert, size_t size, Error **errp)
     return curve_id == GNUTLS_ECC_CURVE_SECP521R1;
 }
 
+int qcrypto_pkcs7_convert_sig_pem(uint8_t *sig, size_t sig_size,
+                                  uint8_t **result, size_t *resultlen,
+                                  Error **errp)
+{
+    int ret = -1;
+    int rc;
+    gnutls_pkcs7_t signature;
+    gnutls_datum_t sig_datum_der = {.data = sig, .size = sig_size};
+    gnutls_datum_t sig_datum_pem = {.data = NULL, .size = 0};
+
+    rc = gnutls_pkcs7_init(&signature);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize pkcs7 data: %s", gnutls_strerror(rc));
+        return ret;
+    }
+
+    rc = gnutls_pkcs7_import(signature, &sig_datum_der, GNUTLS_X509_FMT_DER);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import signature: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_pkcs7_export2(signature, GNUTLS_X509_FMT_PEM, &sig_datum_pem);
+    if (rc != 0) {
+        error_setg(errp, "Failed to convert signature to PEM format: %s",
+                   gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    *resultlen = sig_datum_pem.size;
+    *result = g_memdup2(sig_datum_pem.data, sig_datum_pem.size);
+
+    ret = 0;
+
+cleanup:
+    gnutls_pkcs7_deinit(signature);
+    g_free(sig_datum_pem.data);
+    return ret;
+}
+
+int qcrypto_x509_verify_sig(uint8_t *cert, size_t cert_size,
+                            uint8_t *comp, size_t comp_size,
+                            uint8_t *sig, size_t sig_size, Error **errp)
+{
+    int rc;
+    int ret = -1;
+    gnutls_x509_crt_t crt = NULL;
+    gnutls_pkcs7_t signature = NULL;
+    gnutls_datum_t cert_datum = {.data = cert, .size = cert_size};
+    gnutls_datum_t data_datum = {.data = comp, .size = comp_size};
+    gnutls_datum_t sig_datum = {.data = sig, .size = sig_size};
+
+    rc = gnutls_x509_crt_init(&crt);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_x509_crt_import(crt, &cert_datum, GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import certificate: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_pkcs7_init(&signature);
+    if (rc < 0) {
+        error_setg(errp, "Failed to initialize pkcs7 data: %s", gnutls_strerror(rc));
+        goto cleanup;
+     }
+
+    rc = gnutls_pkcs7_import(signature, &sig_datum , GNUTLS_X509_FMT_PEM);
+    if (rc != 0) {
+        error_setg(errp, "Failed to import signature: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    rc = gnutls_pkcs7_verify_direct(signature, crt, 0, &data_datum, 0);
+    if (rc != 0) {
+        error_setg(errp, "Failed to verify signature: %s", gnutls_strerror(rc));
+        goto cleanup;
+    }
+
+    ret = 0;
+
+cleanup:
+    gnutls_x509_crt_deinit(crt);
+    gnutls_pkcs7_deinit(signature);
+    return ret;
+}
+
 #else /* ! CONFIG_GNUTLS */
 
 int qcrypto_get_x509_cert_fingerprint(uint8_t *cert, size_t size,
@@ -378,4 +469,21 @@ int qcrypto_x509_check_ecc_curve_p521(uint8_t *cert, size_t size, Error **errp)
     return -1;
 }
 
+int qcrypto_pkcs7_convert_sig_pem(uint8_t *sig, size_t sig_size,
+                                  uint8_t **result,
+                                  size_t *resultlen,
+                                  Error **errp)
+{
+    error_setg(errp, "GNUTLS is required to export pkcs7 signature");
+    return -1;
+}
+
+int qcrypto_x509_verify_sig(uint8_t *cert, size_t cert_size,
+                            uint8_t *comp, size_t comp_size,
+                            uint8_t *sig, size_t sig_size, Error **errp)
+{
+    error_setg(errp, "GNUTLS is required for signature-verification support");
+    return -1;
+}
+
 #endif /* ! CONFIG_GNUTLS */
include/crypto/x509-utils.h +41 -0

45 lines not on this page · raw message

Signature · 1 line
2.54.0
#28 lore raw

PATCH v11 13/32 s390x/diag: Implement DIAG 508 subcode 1 for signature verification

In reply to Zhuoying Cai

From: Collin Walling <[email protected]>

DIAG 508 subcode 1 performs signature-verification on signed components. A signed component may be a Linux kernel image, or any other signed binary. **Verification of initrd is not supported.**

The instruction call expects two item-pairs: an address of a device component, an address of the analogous signature file (in PKCS#7 DER format), and their respective lengths. All of this data should be encapsulated within a Diag508SigVerifBlock.

The DIAG handler will read from the provided addresses to retrieve the necessary data, parse the signature file, then perform the signature-verification. Because there is no way to correlate a specific certificate to a component, each certificate in the store is tried until either verification succeeds, or all certs have been exhausted.

A return code of 1 indicates success, and the index and length of the corresponding certificate will be set in the Diag508SigVerifBlock. The following values indicate failure:

	0x0102: no certificates are available in the store
	0x0202: component data is invalid
	0x0302: PKCS#7 format signature is invalid
	0x0402: signature-verification failed
	0x0502: length of Diag508SigVerifBlock is invalid
---
 docs/specs/s390x-secure-ipl.rst |  17 +++++
 include/hw/s390x/ipl/diag508.h  |  30 +++++++++
 target/s390x/diag.c             | 111 +++++++++++++++++++++++++++++++-
 3 files changed, 157 insertions(+), 1 deletion(-)
docs/specs/s390x-secure-ipl.rst +17 -0
index 488981339d..f35e868e4c 100644
@@ -80,3 +80,20 @@ that requires assistance from QEMU.
 
 Subcode 0 - query installed subcodes
     Returns a 64-bit mask indicating which subcodes are supported.
+
+Subcode 1 - perform signature verification
+    Perform signature-verification on a signed component, using certificates
+    from the certificate store and leveraging qcrypto libraries to perform
+    this operation.
+
+    Note: verification of initrd is not supported.
+
+    A return code of 1 indicates success, and the index and length of the
+    corresponding certificate will be set in the Diag508SigVerifBlock.
+    The following values indicate failure:
+
+    * ``0x0102``: no certificates are available in the store
+    * ``0x0202``: component data is invalid
+    * ``0x0302``: PKCS#7 format signature is invalid
+    * ``0x0402``: signature-verification failed
+    * ``0x0502``: length of Diag508SigVerifBlock is invalid
include/hw/s390x/ipl/diag508.h +30 -0
index 6281ad8299..8a147f32a0 100644
@@ -11,5 +11,35 @@
 #define S390X_DIAG508_H
 
 #define DIAG_508_SUBC_QUERY_SUBC    0x0000
+#define DIAG_508_SUBC_SIG_VERIF     0x8000
+
+#define DIAG_508_RC_OK              0x0001
+#define DIAG_508_RC_NO_CERTS        0x0102
+#define DIAG_508_RC_INVAL_COMP_DATA 0x0202
+#define DIAG_508_RC_INVAL_PKCS7_SIG 0x0302
+#define DIAG_508_RC_FAIL_VERIF      0x0402
+#define DIAG_508_RC_INVAL_LEN       0x0502
+
+/*
+ * Maximum componenet and signature sizes for current secure boot implementation
+ * Not architecturally defined and may need to revisit if increased
+ */
+#define DIAG_508_MAX_COMP_LEN      0x10000000
+#define DIAG_508_MAX_SIG_LEN       4096
+
+struct Diag508SigVerifBlock {
+    uint32_t length;
+    uint8_t reserved0[3];
+    uint8_t version;
+    uint32_t reserved[2];
+    uint8_t cert_store_index;
+    uint8_t reserved1[7];
+    uint64_t cert_len;
+    uint64_t comp_len;
+    uint64_t comp_addr;
+    uint64_t sig_len;
+    uint64_t sig_addr;
+};
+typedef struct Diag508SigVerifBlock Diag508SigVerifBlock;
 
 #endif
target/s390x/diag.c +110 -1

126 lines not on this page · raw message

Signature · 1 line
2.54.0
#29 lore raw

PATCH v11 14/32 s390x/ipl: Introduce IPL Information Report Block (IIRB)

In reply to Zhuoying Cai

The IPL information report block (IIRB) contains information used to locate IPL records and to report the results of signature verification of one or more secure components of the load device.

IIRB is stored immediately following the IPL Parameter Block. Results on component verification in any case (failure or success) are stored.

The IIRB data is reserved and protected by the guest kernel during early boot to prevent it from being overwritten before the certificate data is permanently saved.

---
 docs/specs/s390x-secure-ipl.rst | 21 +++++++++++
 include/hw/s390x/ipl/qipl.h     | 62 +++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+)
docs/specs/s390x-secure-ipl.rst +21 -0
index f35e868e4c..c858d5b74b 100644
@@ -97,3 +97,24 @@ Subcode 1 - perform signature verification
     * ``0x0302``: PKCS#7 format signature is invalid
     * ``0x0402``: signature-verification failed
     * ``0x0502``: length of Diag508SigVerifBlock is invalid
+
+IPL Information Report Block
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The IPL Parameter Block (IPLPB), utilized for IPL operation, is extended with an
+IPL Information Report Block (IIRB), which contains the results from secure IPL
+operations such as:
+
+* component data
+* verification results
+* certificate data
+
+During early boot, the guest kernel reserves the memory region
+containing the IIRB. This preserves the data while the guest kernel is
+operating and during re-IPL.
+
+The guest kernel uses the contents in the IIRB for:
+
+* Boot logging: reports which components were loaded and verified.
+* kexec operations: builds the next kernel’s IPL report from the existing one.
+* Keying: installs IPL certificates into the platform trusted keyring.
include/hw/s390x/ipl/qipl.h +62 -0

72 lines not on this page · raw message

Signature · 1 line
2.54.0
#30 lore raw

PATCH v11 15/32 pc-bios/s390-ccw: Define memory for IPLB and convert IPLB to pointers

In reply to Zhuoying Cai

Define a memory space for both IPL Parameter Block (IPLB) and IPL Information Report Block (IIRB) since IIRB is stored immediately following IPLB.

Convert IPLB to pointer and it points to the start of the defined memory space. IIRB points to the end of IPLB.

---
 include/hw/s390x/ipl/qipl.h |  6 ++++++
 pc-bios/s390-ccw/iplb.h     |  5 +++--
 pc-bios/s390-ccw/jump2ipl.c |  6 +++---
 pc-bios/s390-ccw/main.c     | 34 +++++++++++++++++++---------------
 pc-bios/s390-ccw/netmain.c  |  8 ++++----
 5 files changed, 35 insertions(+), 24 deletions(-)
include/hw/s390x/ipl/qipl.h +6 -0
index 45d25264f4..9940f1457c 100644
@@ -208,4 +208,10 @@ struct IplInfoReportBlock {
 };
 typedef struct IplInfoReportBlock IplInfoReportBlock;
 
+struct IplBlocks {
+    IplParameterBlock   iplb;
+    IplInfoReportBlock  iirb;
+};
+typedef struct IplBlocks IplBlocks;
+
 #endif
pc-bios/s390-ccw/iplb.h +3 -2
index 926e8eed5d..c828466f51 100644
@@ -20,8 +20,9 @@
 #include <string.h>
 
 extern QemuIplParameters qipl;
-extern IplParameterBlock iplb __attribute__((__aligned__(PAGE_SIZE)));
+extern IplParameterBlock *iplb;
 extern bool have_iplb;
+extern IplBlocks ipl_data;
 
 static inline bool manage_iplb(IplParameterBlock *iplb, bool store)
 {
@@ -61,7 +62,7 @@ static inline bool load_next_iplb(void)
 
     qipl.index++;
     next_iplb = (IplParameterBlock *) qipl.next_iplb;
-    memcpy(&iplb, next_iplb, sizeof(IplParameterBlock));
+    memcpy(iplb, next_iplb, sizeof(IplParameterBlock));
 
     qipl.chain_len--;
     qipl.next_iplb = qipl.next_iplb + sizeof(IplParameterBlock);
pc-bios/s390-ccw/jump2ipl.c +3 -3
index 86321d0f46..fa2ca5cbe1 100644
@@ -43,11 +43,11 @@ int jump_to_IPL_code(uint64_t address)
      * The IPLB for QEMU SCSI type devices must be rebuilt during re-ipl. The
      * iplb.devno is set to the boot position of the target SCSI device.
      */
-    if (iplb.pbt == S390_IPL_TYPE_QEMU_SCSI) {
-        iplb.devno = qipl.index;
+    if (iplb->pbt == S390_IPL_TYPE_QEMU_SCSI) {
+        iplb->devno = qipl.index;
     }
 
-    if (have_iplb && !set_iplb(&iplb)) {
+    if (have_iplb && !set_iplb(iplb)) {
         panic("Failed to set IPLB");
     }
 
pc-bios/s390-ccw/main.c +19 -15
index 26287cfd81..e6d4105786 100644
@@ -24,7 +24,9 @@
 static SubChannelId blk_schid = { .one = 1 };
 static char loadparm_str[LOADPARM_LEN + 1];
 QemuIplParameters qipl;
-IplParameterBlock iplb __attribute__((__aligned__(PAGE_SIZE)));
+/* Ensure that IPLB and IIRB are page aligned and sequential in memory */
+IplBlocks ipl_data __attribute__((__aligned__(PAGE_SIZE)));
+IplParameterBlock *iplb;
 bool have_iplb;
 static uint16_t cutype;
 LowCore *lowcore; /* Yes, this *is* a pointer to address 0 */
@@ -53,7 +55,7 @@ void write_subsystem_identification(void)
 void write_iplb_location(void)
 {
     if (cutype == CU_TYPE_VIRTIO && virtio_get_device_type() != VIRTIO_ID_NET) {
-        lowcore->ptr_iplb = ptr2u32(&iplb);
+        lowcore->ptr_iplb = ptr2u32(iplb);
     }
 }
 
@@ -213,14 +215,14 @@ static void boot_setup(void)
     char lpmsg[] = "LOADPARM=[________]\n";
     VDev *vdev = virtio_get_device();
 
-    if (have_iplb && memcmp(iplb.loadparm, NO_LOADPARM, LOADPARM_LEN) != 0) {
-        ebcdic_to_ascii((char *) iplb.loadparm, loadparm_str, LOADPARM_LEN);
+    if (have_iplb && memcmp(iplb->loadparm, NO_LOADPARM, LOADPARM_LEN) != 0) {
+        ebcdic_to_ascii((char *) iplb->loadparm, loadparm_str, LOADPARM_LEN);
     } else {
         sclp_get_loadparm_ascii(loadparm_str);
     }
 
     if (have_iplb) {
-        vdev->ipl_type = iplb.pbt;
+        vdev->ipl_type = iplb->pbt;
         menu_setup(vdev);
     } else {
         vdev->ipl_type = QEMU_DEFAULT_IPL;
@@ -244,21 +246,21 @@ static bool find_boot_device(void)
     switch (vdev->ipl_type) {
     case S390_IPL_TYPE_CCW:
         vdev->scsi_device_selected = false;
-        debug_print_int("device no. ", iplb.ccw.devno);
-        blk_schid.ssid = iplb.ccw.ssid & 0x3;
+        debug_print_int("device no. ", iplb->ccw.devno);
+        blk_schid.ssid = iplb->ccw.ssid & 0x3;
         debug_print_int("ssid ", blk_schid.ssid);
-        found = find_subch(iplb.ccw.devno);
+        found = find_subch(iplb->ccw.devno);
         break;
     case S390_IPL_TYPE_QEMU_SCSI:
         vdev->scsi_device_selected = true;
-        vdev->selected_scsi_device.channel = iplb.scsi.channel;
-        vdev->selected_scsi_device.target = iplb.scsi.target;
-        vdev->selected_scsi_device.lun = iplb.scsi.lun;
-        blk_schid.ssid = iplb.scsi.ssid & 0x3;
-        found = find_subch(iplb.scsi.devno);
+        vdev->selected_scsi_device.channel = iplb->scsi.channel;
+        vdev->selected_scsi_device.target = iplb->scsi.target;
+        vdev->selected_scsi_device.lun = iplb->scsi.lun;
+        blk_schid.ssid = iplb->scsi.ssid & 0x3;
+        found = find_subch(iplb->scsi.devno);
         break;
      case S390_IPL_TYPE_PCI:
-        found = find_fid(iplb.pci.fid);
+        found = find_fid(iplb->pci.fid);
         break;
     default:
         puts("Unsupported IPLB");
@@ -377,10 +379,12 @@ static void probe_boot_device(void)
 
 void main(void)
 {
+    iplb = &ipl_data.iplb;
+
     copy_qipl();
     sclp_setup();
     css_setup();
-    have_iplb = store_iplb(&iplb);
+    have_iplb = store_iplb(iplb);
     if (!have_iplb) {
         boot_setup();
         probe_boot_device();
pc-bios/s390-ccw/netmain.c +4 -4
index 651cedf6ef..9b4dfd4638 100644
@@ -528,11 +528,11 @@ static bool virtio_setup(void)
      */
     enable_mss_facility();
 
-    if (have_iplb || store_iplb(&iplb)) {
-        IPL_assert(iplb.pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected");
-        dev_no = iplb.ccw.devno;
+    if (have_iplb || store_iplb(iplb)) {
+        IPL_assert(iplb->pbt == S390_IPL_TYPE_CCW, "IPL_TYPE_CCW expected");
+        dev_no = iplb->ccw.devno;
         debug_print_int("device no. ", dev_no);
-        net_schid.ssid = iplb.ccw.ssid & 0x3;
+        net_schid.ssid = iplb->ccw.ssid & 0x3;
         debug_print_int("ssid ", net_schid.ssid);
         found = find_net_dev(&schib, dev_no);
     } else {
Signature · 1 line
2.54.0
#31 lore raw

PATCH v11 16/32 hw/s390x/ipl: Add IPIB flags to IPL Parameter Block

In reply to Zhuoying Cai

Add IPIB flags to IPL Parameter Block to determine if IPL needs to perform securely and if IPL Information Report Block (IIRB) exists.

Move DIAG308 flags to a separated header file and add flags for secure IPL. Move IPLB length related definitions to include/hw/s390x/ipl/qipl.h and add a maximum length constant to support secure IPL.

Secure boot in audit mode will perform if certificate(s) exist in the key store. IIRB will exist and results of verification will be stored in IIRB.

To ensure proper alignment of the IIRB and prevent overlap, set iplb->len to the maximum length of the IPLB, allowing alignment constraints to be determined based on its size.

---
 hw/s390x/ipl.c                 | 21 +++++++++++++++++++++
 hw/s390x/ipl.h                 | 24 ------------------------
 include/hw/s390x/ipl/diag308.h | 34 ++++++++++++++++++++++++++++++++++
 include/hw/s390x/ipl/qipl.h    | 13 ++++++++++++-
 4 files changed, 67 insertions(+), 25 deletions(-)
 create mode 100644 include/hw/s390x/ipl/diag308.h
hw/s390x/ipl.c +21 -0
index fbef46aee5..f4311f6d62 100644
@@ -461,6 +461,13 @@ S390IPLCertificateStore *s390_ipl_get_certificate_store(void)
     return &ipl->cert_store;
 }
 
+static bool s390_has_certificate(void)
+{
+    S390IPLState *ipl = get_ipl_device();
+
+    return ipl->cert_store.count > 0;
+}
+
 static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
 {
     CcwDevice *ccw_dev = NULL;
@@ -517,6 +524,20 @@ static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
         s390_ipl_convert_loadparm((char *)lp, iplb->loadparm);
         iplb->flags |= DIAG308_FLAGS_LP_VALID;
 
+        /*
+         * Secure boot in audit mode will perform
+         * if certificate(s) exist in the key store.
+         *
+         * IPL Information Report Block (IIRB) will exist
+         * for secure boot in audit mode.
+         *
+         * Results of secure boot will be stored in IIRB.
+         */
+        if (s390_has_certificate()) {
+            iplb->hdr_flags |= DIAG308_IPIB_FLAGS_IPLIR;
+            iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
+        }
+
         return true;
     }
 
hw/s390x/ipl.h +0 -24
index f5a49a4431..9807ef18f2 100644
@@ -23,7 +23,6 @@
 #include "qom/object.h"
 #include "target/s390x/kvm/pv.h"
 
-#define DIAG308_FLAGS_LP_VALID 0x80
 #define MAX_BOOT_DEVS 8 /* Max number of devices that may have a bootindex */
 
 void s390_ipl_convert_loadparm(char *ascii_lp, uint8_t *ebcdic_lp);
@@ -90,29 +89,6 @@ struct S390IPLState {
 };
 QEMU_BUILD_BUG_MSG(offsetof(S390IPLState, iplb) & 3, "alignment of iplb wrong");
 
-#define DIAG_308_RC_OK              0x0001
-#define DIAG_308_RC_NO_CONF         0x0102
-#define DIAG_308_RC_INVALID         0x0402
-#define DIAG_308_RC_NO_PV_CONF      0x0902
-#define DIAG_308_RC_INVAL_FOR_PV    0x0a02
-
-#define DIAG308_RESET_MOD_CLR       0
-#define DIAG308_RESET_LOAD_NORM     1
-#define DIAG308_LOAD_CLEAR          3
-#define DIAG308_LOAD_NORMAL_DUMP    4
-#define DIAG308_SET                 5
-#define DIAG308_STORE               6
-#define DIAG308_PV_SET              8
-#define DIAG308_PV_STORE            9
-#define DIAG308_PV_START            10
-
-#define S390_IPLB_HEADER_LEN 8
-#define S390_IPLB_MIN_PV_LEN 148
-#define S390_IPLB_MIN_CCW_LEN 200
-#define S390_IPLB_MIN_FCP_LEN 384
-#define S390_IPLB_MIN_PCI_LEN 376
-#define S390_IPLB_MIN_QEMU_SCSI_LEN 200
-
 static inline bool iplb_valid_len(IplParameterBlock *iplb)
 {
     return be32_to_cpu(iplb->len) <= sizeof(IplParameterBlock);
include/hw/s390x/ipl/diag308.h new file +34 -0
new file mode 100644
index 0000000000..6e62f29215
@@ -0,0 +1,34 @@
+/*
+ * S/390 DIAGNOSE 308 definitions and structures
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef S390X_DIAG308_H
+#define S390X_DIAG308_H
+
+#define DIAG_308_RC_OK              0x0001
+#define DIAG_308_RC_NO_CONF         0x0102
+#define DIAG_308_RC_INVALID         0x0402
+#define DIAG_308_RC_NO_PV_CONF      0x0902
+#define DIAG_308_RC_INVAL_FOR_PV    0x0a02
+
+#define DIAG308_RESET_MOD_CLR       0
+#define DIAG308_RESET_LOAD_NORM     1
+#define DIAG308_LOAD_CLEAR          3
+#define DIAG308_LOAD_NORMAL_DUMP    4
+#define DIAG308_SET                 5
+#define DIAG308_STORE               6
+#define DIAG308_PV_SET              8
+#define DIAG308_PV_STORE            9
+#define DIAG308_PV_START            10
+
+#define DIAG308_FLAGS_LP_VALID 0x80
+
+#define DIAG308_IPIB_FLAGS_SIPL 0x40
+#define DIAG308_IPIB_FLAGS_IPLIR 0x20
+
+#endif
include/hw/s390x/ipl/qipl.h +12 -1
index 9940f1457c..a2180719b1 100644
@@ -12,6 +12,8 @@
 #ifndef S390X_QIPL_H
 #define S390X_QIPL_H
 
+#include "diag308.h"
+
 /* Boot Menu flags */
 #define QIPL_FLAG_BM_OPTS_CMD   0x80
 #define QIPL_FLAG_BM_OPTS_ZIPL  0x40
@@ -31,6 +33,14 @@ typedef enum S390IplType S390IplType;
 
 #define QEMU_DEFAULT_IPL S390_IPL_TYPE_CCW
 
+#define S390_IPLB_HEADER_LEN 8
+#define S390_IPLB_MIN_PV_LEN 148
+#define S390_IPLB_MIN_CCW_LEN 200
+#define S390_IPLB_MIN_FCP_LEN 384
+#define S390_IPLB_MIN_PCI_LEN 376
+#define S390_IPLB_MIN_QEMU_SCSI_LEN 200
+#define S390_IPLB_MAX_LEN 4096
+
 #define MAX_CERTIFICATES  64
 /* largest supported block size - same as VIRTIO_DASD_DEFAULT_BLOCK_SIZE */
 #define VIRTIO_MAX_BLOCK_SIZE   4096
@@ -125,7 +135,8 @@ typedef struct IplBlockPci IplBlockPci;
 union IplParameterBlock {
     struct {
         uint32_t len;
-        uint8_t  reserved0[3];
+        uint8_t  hdr_flags;
+        uint8_t  reserved0[2];
         uint8_t  version;
         uint32_t blk0_len;
         uint8_t  pbt;
Signature · 1 line
2.54.0
#33 lore raw

PATCH v11 17/32 s390x: Guest support for Secure-IPL Facility

In reply to Zhuoying Cai

Introduce Secure-IPL (SIPL) facility.

Use fac_ipl to represent bytes 136 and 137 for IPL device facilities of the SCLP Read Info block.

Availability of SIPL facility is determined by byte 136 bit 1 of the SCLP Read Info block. Byte 136's facilities cannot be represented without the availability of the extended-length-SCCB, so add it as a check for consistency.

Secure IPL is not available for guests under protected virtualization.

This feature is available starting with the gen16 CPU model.

---
 hw/s390x/sclp.c                     | 2 ++
 include/hw/s390x/sclp.h             | 4 +++-
 target/s390x/cpu_features.c         | 4 ++++
 target/s390x/cpu_features.h         | 1 +
 target/s390x/cpu_features_def.h.inc | 3 +++
 target/s390x/cpu_models.c           | 2 ++
 target/s390x/gen-features.c         | 2 ++
 target/s390x/kvm/kvm.c              | 3 +++
 8 files changed, 20 insertions(+), 1 deletion(-)
hw/s390x/sclp.c +2 -0
index b9c3983df1..666bae33f0 100644
@@ -146,6 +146,8 @@ static void read_SCP_info(SCLPDevice *sclp, SCCB *sccb)
     if (s390_has_feat(S390_FEAT_EXTENDED_LENGTH_SCCB)) {
         s390_get_feat_block(S390_FEAT_TYPE_SCLP_FAC134,
                             &read_info->fac134);
+        s390_get_feat_block(S390_FEAT_TYPE_SCLP_FAC_IPL,
+                            read_info->fac_ipl);
     }
 
     read_info->facilities = cpu_to_be64(SCLP_HAS_CPU_INFO |
include/hw/s390x/sclp.h +3 -1
index ddc61f1c21..a9595d8007 100644
@@ -136,7 +136,9 @@ typedef struct ReadInfo {
     uint32_t hmfai;
     uint8_t  _reserved7[134 - 128];     /* 128-133 */
     uint8_t  fac134;
-    uint8_t  _reserved8[144 - 135];     /* 135-143 */
+    uint8_t  _reserved8;
+    uint8_t  fac_ipl[2];                /* 136-137 */
+    uint8_t  _reserved9[144 - 138];     /* 138-143 */
     struct CPUEntry entries[];
     /*
      * When the Extended-Length SCCB (ELS) feature is enabled the
target/s390x/cpu_features.c +4 -0
index 436471f4b4..200bd8c15b 100644
@@ -119,6 +119,7 @@ void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
      * Some facilities are not available for CPUs in protected mode:
      * - All SIE facilities because SIE is not available
      * - DIAG318
+     * - Secure IPL Facility
      *
      * As VMs can move in and out of protected mode the CPU model
      * doesn't protect us from that problem because it is only
@@ -149,6 +150,9 @@ void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
         clear_be_bit(s390_feat_def(S390_FEAT_DIAG_318)->bit, data);
         clear_be_bit(s390_feat_def(S390_FEAT_CERT_STORE)->bit, data);
         break;
+    case S390_FEAT_TYPE_SCLP_FAC_IPL:
+        clear_be_bit(s390_feat_def(S390_FEAT_SIPL)->bit, data);
+        break;
     default:
         return;
     }
target/s390x/cpu_features.h +1 -0
index 5635839d03..b038198555 100644
@@ -24,6 +24,7 @@ typedef enum {
     S390_FEAT_TYPE_SCLP_CONF_CHAR,
     S390_FEAT_TYPE_SCLP_CONF_CHAR_EXT,
     S390_FEAT_TYPE_SCLP_FAC134,
+    S390_FEAT_TYPE_SCLP_FAC_IPL,
     S390_FEAT_TYPE_SCLP_CPU,
     S390_FEAT_TYPE_MISC,
     S390_FEAT_TYPE_PLO,
target/s390x/cpu_features_def.h.inc +3 -0
index 2976ecd0ee..bcf8a666e4 100644
@@ -140,6 +140,9 @@ DEF_FEAT(SIE_IBS, "ibs", SCLP_CONF_CHAR_EXT, 10, "SIE: Interlock-and-broadcast-s
 DEF_FEAT(DIAG_318, "diag318", SCLP_FAC134, 0, "Control program name and version codes")
 DEF_FEAT(CERT_STORE, "cstore", SCLP_FAC134, 5, "Certificate Store functions")
 
+/* Features exposed via SCLP SCCB Facilities byte 136 - 137 (bit numbers relative to byte-136) */
+DEF_FEAT(SIPL, "sipl", SCLP_FAC_IPL, 1, "Secure-IPL facility")
+
 /* Features exposed via SCLP CPU info. */
 DEF_FEAT(SIE_F2, "sief2", SCLP_CPU, 4, "SIE: interception format 2 (Virtual SIE)")
 DEF_FEAT(SIE_SKEY, "skey", SCLP_CPU, 5, "SIE: Storage-key facility")
target/s390x/cpu_models.c +2 -0
index 962f135f42..a52e34aa95 100644
@@ -263,6 +263,7 @@ bool s390_has_feat(S390Feat feat)
         case S390_FEAT_SIE_CMMA:
         case S390_FEAT_SIE_PFMFI:
         case S390_FEAT_SIE_IBS:
+        case S390_FEAT_SIPL:
         case S390_FEAT_CONFIGURATION_TOPOLOGY:
             return false;
             break;
@@ -507,6 +508,7 @@ static void check_consistency(const S390CPUModel *model)
         { S390_FEAT_AP_QUEUE_INTERRUPT_CONTROL, S390_FEAT_AP },
         { S390_FEAT_DIAG_318, S390_FEAT_EXTENDED_LENGTH_SCCB },
         { S390_FEAT_CERT_STORE, S390_FEAT_EXTENDED_LENGTH_SCCB },
+        { S390_FEAT_SIPL, S390_FEAT_EXTENDED_LENGTH_SCCB },
         { S390_FEAT_NNPA, S390_FEAT_VECTOR },
         { S390_FEAT_RDP, S390_FEAT_LOCAL_TLB_CLEARING },
         { S390_FEAT_UV_FEAT_AP, S390_FEAT_AP },
target/s390x/gen-features.c +2 -0
index 6c20c3a862..bd2060ab93 100644
@@ -721,6 +721,7 @@ static uint16_t full_GEN16_GA1[] = {
     S390_FEAT_UV_FEAT_AP,
     S390_FEAT_UV_FEAT_AP_INTR,
     S390_FEAT_CERT_STORE,
+    S390_FEAT_SIPL,
 };
 
 static uint16_t full_GEN17_GA1[] = {
@@ -922,6 +923,7 @@ static uint16_t qemu_MAX[] = {
     S390_FEAT_PRNO_TRNG,
     S390_FEAT_EXTENDED_LENGTH_SCCB,
     S390_FEAT_CERT_STORE,
+    S390_FEAT_SIPL,
 };
 
 /****** END FEATURE DEFS ******/
target/s390x/kvm/kvm.c +3 -0
index 82f7fed9ec..e76ff37cc3 100644
@@ -2492,6 +2492,9 @@ bool kvm_s390_get_host_cpu_model(S390CPUModel *model, Error **errp)
 
     set_bit(S390_FEAT_CERT_STORE, model->features);
 
+    /* Some Secure IPL facilities are emulated by QEMU */
+    set_bit(S390_FEAT_SIPL, model->features);
+
     /* Test for Ultravisor features that influence secure guest behavior */
     query_uv_feat_guest(model->features);
 
Signature · 1 line
2.54.0
#34 lore raw

PATCH v11 18/32 pc-bios/s390-ccw: Refactor zipl_run()

In reply to Zhuoying Cai

Refactor to enhance readability before enabling secure IPL in later patches.

---
 pc-bios/s390-ccw/bootmap.c | 51 ++++++++++++++++++++++++--------------
 1 file changed, 33 insertions(+), 18 deletions(-)
pc-bios/s390-ccw/bootmap.c +33 -18
index 420ee32eff..b9ba004cfc 100644
@@ -674,12 +674,42 @@ static int zipl_load_segment(ComponentEntry *entry)
     return 0;
 }
 
+static int zipl_run_normal(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
+{
+    ComponentEntry *entry = *entry_ptr;
+
+    while (entry->component_type == ZIPL_COMP_ENTRY_LOAD ||
+           entry->component_type == ZIPL_COMP_ENTRY_SIGNATURE) {
+
+        /* Secure boot is off, so we skip signature entries */
+        if (entry->component_type == ZIPL_COMP_ENTRY_SIGNATURE) {
+            entry++;
+            continue;
+        }
+
+        if (zipl_load_segment(entry)) {
+            return -1;
+        }
+
+        entry++;
+
+        if ((uint8_t *)&entry[1] > tmp_sec + MAX_SECTOR_SIZE) {
+            puts("Wrong entry value");
+            return -EINVAL;
+        }
+    }
+
+    *entry_ptr = entry;
+    return 0;
+}
+
 /* Run a zipl program */
 static int zipl_run(ScsiBlockPtr *pte)
 {
     ComponentHeader *header;
     ComponentEntry *entry;
     uint8_t tmp_sec[MAX_SECTOR_SIZE];
+    int rc;
 
     if (virtio_read(pte->blockno, tmp_sec)) {
         puts("Cannot read header");
@@ -700,25 +730,10 @@ static int zipl_run(ScsiBlockPtr *pte)
 
     /* Load image(s) into RAM */
     entry = (ComponentEntry *)(&header[1]);
-    while (entry->component_type == ZIPL_COMP_ENTRY_LOAD ||
-           entry->component_type == ZIPL_COMP_ENTRY_SIGNATURE) {
-
-        /* We don't support secure boot yet, so we skip signature entries */
-        if (entry->component_type == ZIPL_COMP_ENTRY_SIGNATURE) {
-            entry++;
-            continue;
-        }
-
-        if (zipl_load_segment(entry)) {
-            return -1;
-        }
 
-        entry++;
-
-        if ((uint8_t *)(&entry[1]) > (tmp_sec + MAX_SECTOR_SIZE)) {
-            puts("Wrong entry value");
-            return -EINVAL;
-        }
+    rc = zipl_run_normal(&entry, tmp_sec);
+    if (rc) {
+        return rc;
     }
 
     if (entry->component_type != ZIPL_COMP_ENTRY_EXEC) {
Signature · 1 line
2.54.0
#36 lore raw

PATCH v11 19/32 pc-bios/s390-ccw: Rework zipl_load_segment function

In reply to Zhuoying Cai

Change zipl_load_segment() to accept explicit blockno and address parameters instead of ComponentEntry pointer and return segment length.

Modify this function to allow the caller to specify a memory address where segment data should be loaded into.

seg_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Remove static qualifier and add function declaration to bootmap.h to make it accessible to other modules.

---
 pc-bios/s390-ccw/bootmap.c | 18 ++++++++++--------
 pc-bios/s390-ccw/bootmap.h |  2 ++
 2 files changed, 12 insertions(+), 8 deletions(-)
pc-bios/s390-ccw/bootmap.c +10 -8
index b9ba004cfc..b19981feb1 100644
@@ -613,19 +613,19 @@ static int ipl_eckd(void)
  * IPL a SCSI disk
  */
 
-static int zipl_load_segment(ComponentEntry *entry)
+/*
+ * Returns: length of the segment on success,
+ *          negative value on error.
+ */
+int zipl_load_segment(block_number_t blockno, uint64_t address)
 {
     const int max_entries = (MAX_SECTOR_SIZE / sizeof(ScsiBlockPtr));
     ScsiBlockPtr *bprs = (void *)sec;
     const int bprs_size = sizeof(sec);
-    block_number_t blockno;
-    uint64_t address;
     int i;
     char err_msg[] = "zIPL failed to read BPRS at 0xZZZZZZZZZZZZZZZZ";
     char *blk_no = &err_msg[30]; /* where to print blockno in (those ZZs) */
-
-    blockno = entry->data.blockno;
-    address = entry->compdat.load_addr;
+    int seg_len = 0;
 
     debug_print_int("loading segment at block", blockno);
     debug_print_int("addr", address);
@@ -668,10 +668,12 @@ static int zipl_load_segment(ComponentEntry *entry)
                 puts("zIPL load segment failed");
                 return -EIO;
             }
+
+            seg_len += bprs->size * (bprs[i].blockct + 1);
         }
     } while (blockno);
 
-    return 0;
+    return seg_len;
 }
 
 static int zipl_run_normal(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
@@ -687,7 +689,7 @@ static int zipl_run_normal(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
             continue;
         }
 
-        if (zipl_load_segment(entry)) {
+        if (zipl_load_segment(entry->data.blockno, entry->compdat.load_addr) < 0) {
             return -1;
         }
 
pc-bios/s390-ccw/bootmap.h +2 -0
index 95943441d3..8d61ac383c 100644
@@ -113,6 +113,8 @@ typedef struct ScsiMbr {
     ScsiBlockPtr pt;   /* block pointer to program table */
 } __attribute__ ((packed)) ScsiMbr;
 
+int zipl_load_segment(block_number_t blockno, uint64_t address);
+
 #define ZIPL_MAGIC              "zIPL"
 #define ZIPL_MAGIC_EBCDIC       "\xa9\xc9\xd7\xd3"
 #define IPL1_MAGIC "\xc9\xd7\xd3\xf1" /* == "IPL1" in EBCDIC */
Signature · 1 line
2.54.0
#38 lore raw

PATCH v11 20/32 pc-bios/s390-ccw: Introduce ZiplBootMode enum for IPL mode selection

In reply to Zhuoying Cai

Add ZiplBootMode enumeration to support multiple IPL boot configurations. Boot modes differentiate between normal boot and secure IPL operations, enabled based on boot certificates specified via the boot-certs option.

Normal Mode: IPL when no certificates are provided. No signature verification is performed.

This prepares for future secure IPL modes requiring signature verification.

---
 docs/system/s390x/secure-ipl.rst | 21 +++++++++++++++++++++
 pc-bios/s390-ccw/bootmap.c       | 16 +++++++++++++++-
 pc-bios/s390-ccw/main.c          |  6 ++++++
 pc-bios/s390-ccw/s390-ccw.h      |  6 ++++++
 4 files changed, 48 insertions(+), 1 deletion(-)
docs/system/s390x/secure-ipl.rst +21 -0
index 88df52ce2f..9d7d33f5ed 100644
@@ -18,3 +18,24 @@ Note: certificate files must have a .pem extension.
 .. code-block:: shell
 
     qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
+
+
+IPL Modes
+---------
+
+Multiple IPL modes are available to differentiate between the various IPL
+configurations. These modes are mutually exclusive and enabled based on the
+``boot-certs`` option on the QEMU command line.
+
+Normal Mode
+^^^^^^^^^^^
+
+The absence of certificates will attempt to IPL a guest without secure IPL
+operations. No checks are performed, and no warnings/errors are reported.
+This is the default mode.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio ...
pc-bios/s390-ccw/bootmap.c +15 -1
index b19981feb1..667a69f80d 100644
@@ -733,7 +733,14 @@ static int zipl_run(ScsiBlockPtr *pte)
     /* Load image(s) into RAM */
     entry = (ComponentEntry *)(&header[1]);
 
-    rc = zipl_run_normal(&entry, tmp_sec);
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_NORMAL:
+        rc = zipl_run_normal(&entry, tmp_sec);
+        break;
+    default:
+        panic("Unknown boot mode");
+    }
+
     if (rc) {
         return rc;
     }
@@ -1105,12 +1112,16 @@ void zipl_load(void)
     VDev *vdev = virtio_get_device();
 
     if (vdev->is_cdrom) {
+        IPL_assert((boot_mode == ZIPL_BOOT_MODE_NORMAL),
+                   "Secure boot from ISO image is not supported!");
         ipl_iso_el_torito();
         puts("Failed to IPL this ISO image!");
         return;
     }
 
     if (virtio_get_device_type() == VIRTIO_ID_NET) {
+        IPL_assert((boot_mode == ZIPL_BOOT_MODE_NORMAL),
+                    "Virtio net boot device does not support secure boot!");
         netmain();
         puts("Failed to IPL from this network!");
         return;
@@ -1121,6 +1132,9 @@ void zipl_load(void)
         return;
     }
 
+    IPL_assert((boot_mode == ZIPL_BOOT_MODE_NORMAL),
+                "Secure boot with the ECKD scheme is not supported!");
+
     switch (virtio_get_device_type()) {
     case VIRTIO_ID_BLOCK:
         zipl_load_vblk();
pc-bios/s390-ccw/main.c +6 -0
index e6d4105786..66544f75f5 100644
@@ -30,6 +30,7 @@ IplParameterBlock *iplb;
 bool have_iplb;
 static uint16_t cutype;
 LowCore *lowcore; /* Yes, this *is* a pointer to address 0 */
+ZiplBootMode boot_mode;
 
 #define LOADPARM_PROMPT "PROMPT  "
 #define LOADPARM_EMPTY  "        "
@@ -303,6 +304,9 @@ static void ipl_ccw_device(void)
     switch (cutype) {
     case CU_TYPE_DASD_3990:
     case CU_TYPE_DASD_2107:
+        IPL_assert((boot_mode == ZIPL_BOOT_MODE_NORMAL),
+                    "Passthrough (vfio) CCW device does not support secure boot!");
+
         dasd_ipl(blk_schid, cutype);
         break;
     case CU_TYPE_VIRTIO:
@@ -390,6 +394,8 @@ void main(void)
         probe_boot_device();
     }
 
+    boot_mode = ZIPL_BOOT_MODE_NORMAL;
+
     while (have_iplb) {
         boot_setup();
         if (have_iplb && find_boot_device()) {
pc-bios/s390-ccw/s390-ccw.h +6 -0
index 1e1f71775e..5420443ad2 100644
@@ -69,6 +69,12 @@ int sclp_read(char *str, size_t count);
 /* bootmap.c */
 void zipl_load(void);
 
+typedef enum ZiplBootMode {
+    ZIPL_BOOT_MODE_NORMAL = 0,
+} ZiplBootMode;
+
+extern ZiplBootMode boot_mode;
+
 /* jump2ipl.c */
 void write_reset_psw(uint64_t psw);
 int jump_to_IPL_code(uint64_t address);
Signature · 1 line
2.54.0
#40 lore raw

PATCH v11 21/32 pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

In reply to Zhuoying Cai

Enable secure IPL in audit mode, which performs signature verification, but any error does not terminate the boot process. Only warnings will be logged to the console instead.

Add a comp_len variable to store the length of a segment in zipl_load_segment. comp_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities (Secure IPL Facility, Certificate Store Facility and secure IPL extension support).

Note: Secure IPL in audit mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
 docs/system/s390x/secure-ipl.rst |  15 ++
 pc-bios/s390-ccw/Makefile        |   2 +-
 pc-bios/s390-ccw/bootmap.c       |  16 ++
 pc-bios/s390-ccw/bootmap.h       |   9 +
 pc-bios/s390-ccw/main.c          |  10 +-
 pc-bios/s390-ccw/s390-ccw.h      |  24 ++
 pc-bios/s390-ccw/sclp.c          |  27 +++
 pc-bios/s390-ccw/sclp.h          |   6 +
 pc-bios/s390-ccw/secure-ipl.c    | 364 +++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h    | 113 ++++++++++
 10 files changed, 584 insertions(+), 2 deletions(-)
 create mode 100644 pc-bios/s390-ccw/secure-ipl.c
 create mode 100644 pc-bios/s390-ccw/secure-ipl.h
docs/system/s390x/secure-ipl.rst +15 -0
index 9d7d33f5ed..cf6ccf5d57 100644
@@ -39,3 +39,18 @@ Configuration:
 .. code-block:: shell
 
     qemu-system-s390x -machine s390-ccw-virtio ...
+
+Audit Mode
+^^^^^^^^^^
+
+When the certificate store is populated with at least one certificate
+and no additional secure IPL parameters are provided on the command
+line, then secure IPL will proceed in "audit mode". All secure IPL
+operations will be performed with signature verification errors reported
+as non-disruptive warnings.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/Makefile +1 -1
index 3e5dfb64d5..2109d16781 100644
@@ -35,7 +35,7 @@ QEMU_DGFLAGS = -MMD -MP -MT $@ -MF $(@D)/$(*F).d
 
 OBJECTS = start.o main.o bootmap.o jump2ipl.o sclp.o menu.o netmain.o \
 	  virtio.o virtio-net.o virtio-scsi.o virtio-blkdev.o cio.o dasd-ipl.o \
-	  virtio-ccw.o clp.o pci.o virtio-pci.o
+	  virtio-ccw.o clp.o pci.o virtio-pci.o secure-ipl.o
 
 SLOF_DIR := $(SRC_PATH)/../../roms/SLOF
 
pc-bios/s390-ccw/bootmap.c +16 -0
index 667a69f80d..a300fba8cd 100644
@@ -15,6 +15,7 @@
 #include "bootmap.h"
 #include "virtio.h"
 #include "bswap.h"
+#include "secure-ipl.h"
 
 #ifdef DEBUG
 /* #define DEBUG_FALLBACK */
@@ -737,6 +738,9 @@ static int zipl_run(ScsiBlockPtr *pte)
     case ZIPL_BOOT_MODE_NORMAL:
         rc = zipl_run_normal(&entry, tmp_sec);
         break;
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        rc = zipl_run_secure(&entry, tmp_sec);
+        break;
     default:
         panic("Unknown boot mode");
     }
@@ -1107,6 +1111,18 @@ static int zipl_load_vscsi(void)
  * IPL starts here
  */
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags)
+{
+    bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
+    bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+
+    if (!sipl_set && iplir_set) {
+        return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    }
+
+    return ZIPL_BOOT_MODE_NORMAL;
+}
+
 void zipl_load(void)
 {
     VDev *vdev = virtio_get_device();
pc-bios/s390-ccw/bootmap.h +9 -0
index 8d61ac383c..1e00454a1f 100644
@@ -88,9 +88,18 @@ typedef struct BootMapTable {
     BootMapPointer entry[];
 } __attribute__ ((packed)) BootMapTable;
 
+#define DER_SIGNATURE_FORMAT 1
+
+typedef struct SignatureInformation {
+    uint8_t format;
+    uint8_t reserved[3];
+    uint32_t sig_len;
+} SignatureInformation;
+
 typedef union ComponentEntryData {
     uint64_t load_psw;
     uint64_t load_addr;
+    SignatureInformation sig_info;
 } ComponentEntryData;
 
 typedef struct ComponentEntry {
pc-bios/s390-ccw/main.c +9 -1
index 66544f75f5..0bcd32b059 100644
@@ -394,7 +394,15 @@ void main(void)
         probe_boot_device();
     }
 
-    boot_mode = ZIPL_BOOT_MODE_NORMAL;
+    boot_mode = get_boot_mode(iplb->hdr_flags);
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        if (!secure_ipl_supported()) {
+            panic("Unable to boot in audit mode");
+        }
+    default:
+        break;
+    }
 
     while (have_iplb) {
         boot_setup();
pc-bios/s390-ccw/s390-ccw.h +24 -0
index 5420443ad2..b66a9b50bf 100644
@@ -40,6 +40,22 @@ typedef unsigned long long u64;
                             ((b) == 0 ? (a) : (MIN(a, b))))
 #endif
 
+/*
+ * Round number down to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_DOWN
+#define ROUND_DOWN(n, d) ((n) & -(0 ? (n) : (d)))
+#endif
+
+/*
+ * Round number up to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_UP
+#define ROUND_UP(n, d) ROUND_DOWN((n) + (d) - 1, (d))
+#endif
+
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
 #include "cio.h"
@@ -64,6 +80,8 @@ void sclp_print(const char *string);
 void sclp_set_write_mask(uint32_t receive_mask, uint32_t send_mask);
 void sclp_setup(void);
 void sclp_get_loadparm_ascii(char *loadparm);
+bool sclp_is_diag320_on(void);
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag);
 int sclp_read(char *str, size_t count);
 
 /* bootmap.c */
@@ -71,10 +89,16 @@ void zipl_load(void);
 
 typedef enum ZiplBootMode {
     ZIPL_BOOT_MODE_NORMAL = 0,
+    ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
 } ZiplBootMode;
 
 extern ZiplBootMode boot_mode;
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags);
+
+/* secure-ipl.c */
+bool secure_ipl_supported(void);
+
 /* jump2ipl.c */
 void write_reset_psw(uint64_t psw);
 int jump_to_IPL_code(uint64_t address);
pc-bios/s390-ccw/sclp.c +27 -0
index 4a07de018d..48bdfedf1f 100644
@@ -113,6 +113,33 @@ void sclp_get_loadparm_ascii(char *loadparm)
     }
 }
 
+bool sclp_is_diag320_on(void)
+{
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac134 & SCCB_FAC134_DIAG320_BIT;
+    }
+
+    return 0;
+}
+
+/* check if specified IPL facility flag is enabled */
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag)
+{
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac_ipl & fac_ipl_flag;
+    }
+
+    return 0;
+}
+
 int sclp_read(char *str, size_t count)
 {
     ReadEventData *sccb = (void *)_sccb;
pc-bios/s390-ccw/sclp.h +6 -0
index 64b53cad29..a8a41cd004 100644
@@ -50,6 +50,8 @@ typedef struct SCCBHeader {
 } __attribute__((packed)) SCCBHeader;
 
 #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
+#define SCCB_FAC134_DIAG320_BIT 0x4
+#define SCCB_FAC_IPL_SIPL_BIT   0x4000
 
 typedef struct ReadInfo {
     SCCBHeader h;
@@ -57,6 +59,10 @@ typedef struct ReadInfo {
     uint8_t rnsize;
     uint8_t reserved[13];
     uint8_t loadparm[LOADPARM_LEN];
+    uint8_t reserved1[102];
+    uint8_t fac134;
+    uint8_t reserved2;
+    uint16_t fac_ipl;
 } __attribute__((packed)) ReadInfo;
 
 typedef struct SCCB {
pc-bios/s390-ccw/secure-ipl.c new file +364 -0

364 lines not on this page · raw message

pc-bios/s390-ccw/secure-ipl.h new file +113 -0

113 lines not on this page · raw message

Signature · 1 line
2.54.0
#41 lore raw

Re: [PATCH v11 21/32] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

Quoted 8 lines · Zhuoying Cai

Enable secure IPL in audit mode, which performs signature verification, but any error does not terminate the boot process. Only warnings will be logged to the console instead.

Add a comp_len variable to store the length of a segment in zipl_load_segment. comp_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Not sure I understand this part of the commit message. Maybe omit?

Quoted 208 lines

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities (Secure IPL Facility, Certificate Store Facility and secure IPL extension support).

Note: Secure IPL in audit mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
 docs/system/s390x/secure-ipl.rst |  15 ++
 pc-bios/s390-ccw/Makefile        |   2 +-
 pc-bios/s390-ccw/bootmap.c       |  16 ++
 pc-bios/s390-ccw/bootmap.h       |   9 +
 pc-bios/s390-ccw/main.c          |  10 +-
 pc-bios/s390-ccw/s390-ccw.h      |  24 ++
 pc-bios/s390-ccw/sclp.c          |  27 +++
 pc-bios/s390-ccw/sclp.h          |   6 +
 pc-bios/s390-ccw/secure-ipl.c    | 364 +++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h    | 113 ++++++++++
 10 files changed, 584 insertions(+), 2 deletions(-)
 create mode 100644 pc-bios/s390-ccw/secure-ipl.c
 create mode 100644 pc-bios/s390-ccw/secure-ipl.h
docs/system/s390x/secure-ipl.rst +15 -0
index 9d7d33f5ed..cf6ccf5d57 100644
@@ -39,3 +39,18 @@ Configuration:
 .. code-block:: shell
 
     qemu-system-s390x -machine s390-ccw-virtio ...
+
+Audit Mode
+^^^^^^^^^^
+
+When the certificate store is populated with at least one certificate
+and no additional secure IPL parameters are provided on the command
+line, then secure IPL will proceed in "audit mode". All secure IPL
+operations will be performed with signature verification errors reported
+as non-disruptive warnings.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/Makefile +1 -1
index 3e5dfb64d5..2109d16781 100644
@@ -35,7 +35,7 @@ QEMU_DGFLAGS = -MMD -MP -MT $@ -MF $(@D)/$(*F).d
 
 OBJECTS = start.o main.o bootmap.o jump2ipl.o sclp.o menu.o netmain.o \
 	  virtio.o virtio-net.o virtio-scsi.o virtio-blkdev.o cio.o dasd-ipl.o \
-	  virtio-ccw.o clp.o pci.o virtio-pci.o
+	  virtio-ccw.o clp.o pci.o virtio-pci.o secure-ipl.o
 
 SLOF_DIR := $(SRC_PATH)/../../roms/SLOF
 
pc-bios/s390-ccw/bootmap.c +16 -0
index 667a69f80d..a300fba8cd 100644
@@ -15,6 +15,7 @@
 #include "bootmap.h"
 #include "virtio.h"
 #include "bswap.h"
+#include "secure-ipl.h"
 
 #ifdef DEBUG
 /* #define DEBUG_FALLBACK */
@@ -737,6 +738,9 @@ static int zipl_run(ScsiBlockPtr *pte)
     case ZIPL_BOOT_MODE_NORMAL:
         rc = zipl_run_normal(&entry, tmp_sec);
         break;
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        rc = zipl_run_secure(&entry, tmp_sec);
+        break;
     default:
         panic("Unknown boot mode");
     }
@@ -1107,6 +1111,18 @@ static int zipl_load_vscsi(void)
  * IPL starts here
  */
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags)
+{
+    bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
+    bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+
+    if (!sipl_set && iplir_set) {
+        return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    }
+
+    return ZIPL_BOOT_MODE_NORMAL;
+}
+
 void zipl_load(void)
 {
     VDev *vdev = virtio_get_device();
pc-bios/s390-ccw/bootmap.h +9 -0
index 8d61ac383c..1e00454a1f 100644
@@ -88,9 +88,18 @@ typedef struct BootMapTable {
     BootMapPointer entry[];
 } __attribute__ ((packed)) BootMapTable;
 
+#define DER_SIGNATURE_FORMAT 1
+
+typedef struct SignatureInformation {
+    uint8_t format;
+    uint8_t reserved[3];
+    uint32_t sig_len;
+} SignatureInformation;
+
 typedef union ComponentEntryData {
     uint64_t load_psw;
     uint64_t load_addr;
+    SignatureInformation sig_info;
 } ComponentEntryData;
 
 typedef struct ComponentEntry {
pc-bios/s390-ccw/main.c +9 -1
index 66544f75f5..0bcd32b059 100644
@@ -394,7 +394,15 @@ void main(void)
         probe_boot_device();
     }
 
-    boot_mode = ZIPL_BOOT_MODE_NORMAL;
+    boot_mode = get_boot_mode(iplb->hdr_flags);
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        if (!secure_ipl_supported()) {
+            panic("Unable to boot in audit mode");
+        }
+    default:
+        break;
+    }
 
     while (have_iplb) {
         boot_setup();
pc-bios/s390-ccw/s390-ccw.h +24 -0
index 5420443ad2..b66a9b50bf 100644
@@ -40,6 +40,22 @@ typedef unsigned long long u64;
                             ((b) == 0 ? (a) : (MIN(a, b))))
 #endif
 
+/*
+ * Round number down to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_DOWN
+#define ROUND_DOWN(n, d) ((n) & -(0 ? (n) : (d)))
+#endif
+
+/*
+ * Round number up to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_UP
+#define ROUND_UP(n, d) ROUND_DOWN((n) + (d) - 1, (d))
+#endif
+
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
 #include "cio.h"
@@ -64,6 +80,8 @@ void sclp_print(const char *string);
 void sclp_set_write_mask(uint32_t receive_mask, uint32_t send_mask);
 void sclp_setup(void);
 void sclp_get_loadparm_ascii(char *loadparm);
+bool sclp_is_diag320_on(void);
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag);
 int sclp_read(char *str, size_t count);
 
 /* bootmap.c */
@@ -71,10 +89,16 @@ void zipl_load(void);
 
 typedef enum ZiplBootMode {
     ZIPL_BOOT_MODE_NORMAL = 0,
+    ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
 } ZiplBootMode;
 
 extern ZiplBootMode boot_mode;
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags);
+
+/* secure-ipl.c */
+bool secure_ipl_supported(void);
+
 /* jump2ipl.c */
 void write_reset_psw(uint64_t psw);
 int jump_to_IPL_code(uint64_t address);
pc-bios/s390-ccw/sclp.c +2 -0
index 4a07de018d..48bdfedf1f 100644
@@ -113,6 +113,33 @@ void sclp_get_loadparm_ascii(char *loadparm)
     }
 }
 
+bool sclp_is_diag320_on(void)
+{

pc-bios/s390-ccw/sclp.c void sclp_get_loadparm_ascii(char *loadparm) · line 127

Quoted 10 lines
pc-bios/s390-ccw/sclp.c +10 -0
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac134 & SCCB_FAC134_DIAG320_BIT;
+    }
+
+    return 0;
+}

Let's make a note for future work (outside the scope of these patches) to rework the service calls to get the read scp info. Ideally, the call should happen once and the necessary data (loadparm, facility bits, etc) can be referenced when needed.

Quoted 65 lines
pc-bios/s390-ccw/sclp.c +15 -0
+
+/* check if specified IPL facility flag is enabled */
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag)
+{
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac_ipl & fac_ipl_flag;
+    }
+
+    return 0;
+}
+
 int sclp_read(char *str, size_t count)
 {
     ReadEventData *sccb = (void *)_sccb;
pc-bios/s390-ccw/sclp.h +6 -0
index 64b53cad29..a8a41cd004 100644
@@ -50,6 +50,8 @@ typedef struct SCCBHeader {
 } __attribute__((packed)) SCCBHeader;
 
 #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
+#define SCCB_FAC134_DIAG320_BIT 0x4
+#define SCCB_FAC_IPL_SIPL_BIT   0x4000
 
 typedef struct ReadInfo {
     SCCBHeader h;
@@ -57,6 +59,10 @@ typedef struct ReadInfo {
     uint8_t rnsize;
     uint8_t reserved[13];
     uint8_t loadparm[LOADPARM_LEN];
+    uint8_t reserved1[102];
+    uint8_t fac134;
+    uint8_t reserved2;
+    uint16_t fac_ipl;
 } __attribute__((packed)) ReadInfo;
 
 typedef struct SCCB {
pc-bios/s390-ccw/secure-ipl.c new file +17 -0
new file mode 100644
index 0000000000..6e943446a7
@@ -0,0 +1,364 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Functions to support IPL in secure boot mode (DIAG 320, DIAG 508,
+ * signature verification, and certificate handling).
+ *
+ * For secure IPL overview: docs/system/s390x/secure-ipl.rst
+ * For secure IPL technical: docs/specs/s390x-secure-ipl.rst
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <stdlib.h>
+#include <string.h>

pc-bios/s390-ccw/secure-ipl.c line 27

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+#include <stdio.h>
+#include "bootmap.h"
+#include "s390-ccw.h"
+#include "sclp.h"
+#include "secure-ipl.h"
+
+static VCStorageSizeBlock vcssb __attribute__((__aligned__(8)));
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void)
+{

The return is never captured (only checked). Since the vcssb is global and set within the function anyway, it would be a lot cleaner to just call this function near the beginning of zipl_run_secure() and return success/fail values. If the DIAG 320 cert store cannot be queried, then secure IPL can't proceed.

Handle the errors accordingly.

Quoted 12 lines
pc-bios/s390-ccw/secure-ipl.c new file +12 -0
+    /* avoid retrieving vcssb multiple times */
+    if (vcssb.length == VCSSB_MIN_LEN) {
+        return &vcssb;
+    }
+
+    vcssb.length = VCSSB_MIN_LEN;
+    if (_diag320(&vcssb, DIAG_320_SUBC_QUERY_VCSI) != DIAG_320_RC_OK) {
+        vcssb.length = 0;
+        return NULL;
+    }
+
+    return &vcssb;

pc-bios/s390-ccw/secure-ipl.c line 50

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+}
+
+static uint32_t get_total_certs_length(void)
+{
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }> +
+    return vcssb.total_vcb_len - sizeof(VCBlockHeader) -
+           vcssb.total_vc_ct * sizeof(VCEntryHeader);
+}

The function is used when allocating mem for cert_buf... what happens when the value is 0? This could happen if vcssb wasn't queried, or if the calculation returns 0 (possible if there aren't any certs).

I understand sig verif would need to return true before we enter the code that would attempt to store cert data (which I guess wouldn't if there aren't any certs?), but it seems dangerous to have a variable that was malloc(0)'d floating around...

pc-bios/s390-ccw/secure-ipl.c line 59

Quoted 9 lines
pc-bios/s390-ccw/secure-ipl.c new file +9 -0
+
+static uint32_t request_certificate(uint8_t *cert_buf, uint8_t index)
+{
+    VCEntryHeader *vce_hdr;
+    struct vcb {
+        VCBlockHeader vcb_hdr;
+        struct vce {
+            VCEntryHeader vce_hdr;
+            uint8_t cert_buf[CERT_BUF_MAX_LEN];

Use vsccb->max_single_vcb_len here.

If the CERT_BUF_MAX_LEN bound is still required, then it belongs in the cert store or DIAG 320 logic -- if the user tries to store a certificate that exceeds this bound, then don't allow it to be stored at all (and let the user know why with an error).

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+        } vce;
+    } __attribute__((__aligned__(4096))) vcb = { 0 };
+
+    /* Get Verification Certificate Storage Size block with DIAG320 subcode 1 */
+    if (zipl_secure_get_vcssb() == NULL) {

pc-bios/s390-ccw/secure-ipl.c line 74

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+        return 0;
+    }
+
+    /*
+     * Request single entry
+     * Fill input fields of single-entry VCB
+     *
+     * First and last index must be equal because only one
+     * VCE per VCB is currently supported
+     */

The last sentence is misleading because it seems like the DIAG 320 implementation *only* allows for a single VCE to be retrieved, but in reality it allows for a range of entries to be retrieved.

pc-bios/s390-ccw/secure-ipl.c line 80

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c new file +6 -0
+    vcb.vcb_hdr.in_len = ROUND_UP(vcssb.max_single_vcb_len, PAGE_SIZE);
+    vcb.vcb_hdr.first_vc_index = index;
+    vcb.vcb_hdr.last_vc_index = index;
+
+    if (_diag320(&vcb, DIAG_320_SUBC_STORE_VC) != DIAG_320_RC_OK) {
+        return 0;

Maybe move the puts("Could not get certificate"); to here so it's consistent with the other error cases?

pc-bios/s390-ccw/secure-ipl.c line 89

Quoted 9 lines
pc-bios/s390-ccw/secure-ipl.c new file +9 -0
+    }
+
+    if (vcb.vcb_hdr.out_len == sizeof(VCBlockHeader)) {
+        puts("No certificate entry");
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.remain_ct != 0) {
+        panic("Not enough memory to store all requested certificates");

Shouldn't this be "to store requested certificate" since this function aims to request only one cert?

Also, is there a reason for the panic? Why not just puts and return 0 like the rest? The program will still terminate, but a little more gracefully that way.

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c new file +6 -0
+    }
+
+    vce_hdr = &vcb.vce.vce_hdr;
+    if (!(vce_hdr->flags & DIAG_320_VCE_FLAGS_VALID)) {
+        puts("Invalid certificate");
+        return 0;

pc-bios/s390-ccw/secure-ipl.c line 105

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+    }
+
+    memcpy(cert_buf, (uint8_t *)&vcb.vce + vce_hdr->cert_offset, vce_hdr->cert_len);
+
+    return vce_hdr->cert_len;
+}
+
+static int cert_list_add(IplSignatureCertificateList *cert_list,
+                         uint8_t *cert_buf, uint64_t cert_len)
+{

See below where I mention a change to comp_list_add: same idea for this function with an IplSignatureCertificateEntry parameter.

pc-bios/s390-ccw/secure-ipl.c line 111

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c new file +6 -0
+    static bool warned;
+    int cert_entry_idx;
+
+    cert_entry_idx = (cert_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplSignatureCertificateEntry);
+    if (cert_entry_idx > MAX_CERTIFICATES - 1) {

The certificate store, cert table, and cert list are all bounded by MAX_CERTIFICATES (64). Would this check ever occur?

Quoted 9 lines
pc-bios/s390-ccw/secure-ipl.c new file +9 -0
+        if (!warned) {
+            printf("Warning: only %d cert entries are supported;"
+                   " additional entries are ignored\n",
+                   MAX_CERTIFICATES);
+            warned = true;
+        }
+        return cert_entry_idx;
+    }
+

pc-bios/s390-ccw/secure-ipl.c line 130

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+    cert_list->cert_entries[cert_entry_idx].addr = (uint64_t)cert_buf;
+    cert_list->cert_entries[cert_entry_idx].len = cert_len;
+    cert_list->ipl_info_header.len += sizeof(IplSignatureCertificateEntry);
+
+    return cert_entry_idx;
+}
+
+static void comp_list_add(IplDeviceComponentList *comp_list,
+                          SecureIplCompEntryInfo comp_entry_info)
+{

This function could be passed an IplDeviceComponentEntry entry parameter. Then this function becomes:

// get idx

// bounds check

comp_list->device_entries[compy_entry_idx] = entry;

// update header len

Quoted 8 lines
pc-bios/s390-ccw/secure-ipl.c new file +8 -0
+    int comp_entry_idx;
+
+    comp_entry_idx = (comp_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplDeviceComponentEntry);
+    if (comp_entry_idx > MAX_COMP_ENTRIES - 1) {
+        printf("Warning: only %d component entries are supported\n",
+                MAX_COMP_ENTRIES);
+        panic("The device component list has reached its maximum capacity");

pc-bios/s390-ccw/secure-ipl.c line 148

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+    }
+
+    comp_list->device_entries[comp_entry_idx].addr = comp_entry_info.addr;
+    comp_list->device_entries[comp_entry_idx].len = comp_entry_info.len;
+    comp_list->device_entries[comp_entry_idx].flags = comp_entry_info.flags;
+    /* cert index field is meaningful only when S390_IPL_DEV_COMP_FLAG_SC is set */
+    if (comp_entry_info.flags & S390_IPL_DEV_COMP_FLAG_SC) {
+        comp_list->device_entries[comp_entry_idx].cert_index =
+                                                  comp_entry_info.cert_index;
+    }

Does this flag need to be checked at all? Before comp_list_add is called, the S390_IPL_DEV_COMP_FLAG_SC seems to have been unconditionally set beforehand anyway.

Or did you mean to check if S390_IPL_DEV_COMP_FLAG_CSV was set (which means the index was set).

Regardless, if this is changed to be passed an IplDeviceComponentEntry, then the check isn't necessary since all the logic for setting the fields in the entry should be handled prior to the call to this function.

Quoted 84 lines
pc-bios/s390-ccw/secure-ipl.c new file +84 -0
+    comp_list->ipl_info_header.len += sizeof(IplDeviceComponentEntry);
+}
+
+static void update_iirb(IplDeviceComponentList *comp_list,
+                        IplSignatureCertificateList *cert_list)
+{
+    IplInfoReportBlock *iirb;
+    IplDeviceComponentList *iirb_comps;
+    IplSignatureCertificateList *iirb_certs;
+    uint32_t iirb_hdr_len;
+    uint32_t comps_len;
+    uint32_t certs_len;
+
+    if (iplb->len % 8 != 0) {
+        panic("IPL parameter block length field value is not multiple of 8 bytes");
+    }
+
+    iirb_hdr_len = sizeof(IplInfoReportBlockHeader);
+    comps_len = comp_list->ipl_info_header.len;
+    certs_len = cert_list->ipl_info_header.len;
+    if ((comps_len + certs_len + iirb_hdr_len) > sizeof(IplInfoReportBlock)) {
+        panic("Not enough space to hold all components and certificates in IIRB");
+    }
+
+    /* IIRB immediately follows IPLB */
+    iirb = &ipl_data.iirb;
+    iirb->hdr.len = iirb_hdr_len;
+
+    /* Copy IPL device component list after IIRB Header */
+    iirb_comps = (IplDeviceComponentList *) iirb->info_blks;
+    memcpy(iirb_comps, comp_list, comps_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += comps_len;
+
+    /* Copy IPL sig cert list after IPL device component list */
+    iirb_certs = (IplSignatureCertificateList *) (iirb->info_blks +
+                                                  iirb_comps->ipl_info_header.len);
+    memcpy(iirb_certs, cert_list, certs_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += certs_len;
+}
+
+bool secure_ipl_supported(void)
+{
+    if (!sclp_is_fac_ipl_flag_on(SCCB_FAC_IPL_SIPL_BIT)) {
+        puts("Secure IPL Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_signature_verif_supported()) {
+        puts("Secure IPL extensions are not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_cert_store_facility_supported()) {
+        puts("Certificate Store Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    return true;
+}
+
+static void init_lists(IplDeviceComponentList *comp_list,
+                       IplSignatureCertificateList *cert_list)
+{
+    comp_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_COMPONENTS;
+    comp_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+
+    cert_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_CERTIFICATES;
+    cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+}
+
+static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
+{
+    if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
+        puts("Signature is not in DER format");
+        return -1;
+    }
+
+    if (zipl_load_segment(entry->data.blockno, sig) < 0) {
+        return -1;
+    }

pc-bios/s390-ccw/secure-ipl.c line 242

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+
+    return entry->compdat.sig_info.sig_len;
+}
+
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
+{
+    IplDeviceComponentList comp_list = { 0 };
+    IplSignatureCertificateList cert_list = { 0 };
+    SecureIplCompEntryInfo sig_entry_info = { 0 };
+    SecureIplCompEntryInfo comp_entry_info;

Wouldn't an IplSignatureCertificateEntry and IplDeviceComponentEntry suffice here instead? Then the info structs can go away.

(I acknowledge I suggested the info structs previously as a means to reduce parameters passed to certain functions, but I missed that the existing structs should be sufficient).

Quoted 11 lines
pc-bios/s390-ccw/secure-ipl.c new file +11 -0
+    ComponentEntry *entry = *entry_ptr;
+    uint8_t *cert_buf = NULL;
+    int sig_len = 0;
+    int comp_len;
+    int cert_entry_idx;
+    uint64_t comp_addr;
+    uint64_t cert_len;
+    uint8_t cert_table_idx;
+    bool verified;
+    /*
+     * Keep track of which certificate store indices correspond to the

pc-bios/s390-ccw/secure-ipl.c line 263

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+     * certificate data entries within the IplSignatureCertificateList to
+     * prevent allocating space for the same certificate multiple times.
+     *
+     * The array index corresponds to the certificate's cert-store index.
+     *
+     * The array value corresponds to the certificate's entry within the
+     * IplSignatureCertificateList (with a value of -1 denoting no entry
+     * exists for the certificate).
+     */
+    int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };

Use vcssb->max_vc_ct or total_vc_ct. The value comes out the same, but it allows the code in the BIOS to be closer tied to the DIAG 320 and S390 cert store bounds.

This would ensure that the table has enough space to account for all certificates in the store.

Also keep in mind: verify_signature will return idx +1 to align with the DIAG 320 cert store indexing. This means it's possible the function could return a value equal to MAX_CERTIFICATES + 1, which exceeds the buffer.

pc-bios/s390-ccw/secure-ipl.c line 267

Quoted 4 lines
pc-bios/s390-ccw/secure-ipl.c new file +4 -0
+    int signed_count = 0;
+
+    init_lists(&comp_list, &cert_list);
+    cert_buf = malloc(get_total_certs_length());

Are we certain this memory won't get clobbered after the BIOS exits? From what I understand, kernel boot startup will read the IIRB from lowcore (protected area) and then copy each cert from the addresses into some memory region managed by the kernel (protected) and later loaded into the platform keyring.

However, cert_buf exists on the heap (unprotected). Does this memory get reclaimed between BIOS exit and the kernel starts to boot? What protects this memory so that the kernel can successfully read from the addresses?

Maybe the timing just works out and this is an overthought... but the design seems fragile..?

The same questions stand for the component addresses as well.

Quoted 69 lines
pc-bios/s390-ccw/secure-ipl.c new file +69 -0
+    sig_entry_info.addr = (uint64_t)malloc(MAX_SECTOR_SIZE);
+
+    while (entry->component_type != ZIPL_COMP_ENTRY_EXEC) {
+        switch (entry->component_type) {
+        case ZIPL_COMP_ENTRY_SIGNATURE:
+            if (sig_entry_info.len) {
+                goto out;
+            }
+
+            sig_len = zipl_load_signature(entry, sig_entry_info.addr);
+            if (sig_len < 0) {
+                goto out;
+            }
+
+            sig_entry_info.len = sig_len;
+            break;
+        case ZIPL_COMP_ENTRY_LOAD:
+            comp_addr = entry->compdat.load_addr;
+            comp_len = zipl_load_segment(entry->data.blockno, comp_addr);
+            if (comp_len < 0) {
+                goto out;
+            }
+
+            comp_entry_info = (SecureIplCompEntryInfo){ 0 };
+            comp_entry_info.addr = comp_addr;
+            comp_entry_info.len = (uint64_t)comp_len;
+
+            /* no signature present (unsigned component) */
+            if (!sig_entry_info.len) {
+                break;
+            }
+
+            /*
+             * Initialize with SC flag (signed component)
+             * CSV flag set upon successful verification
+             */
+            comp_entry_info.flags = S390_IPL_DEV_COMP_FLAG_SC;
+
+            verified = verify_signature(comp_entry_info, sig_entry_info,
+                                        &cert_len, &cert_table_idx);
+
+            if (verified) {
+                if (cert_list_table[cert_table_idx] == -1) {
+                    if (!request_certificate(cert_buf, cert_table_idx)) {
+                        puts("Could not get certificate");
+                        goto out;
+                    }
+
+                    cert_entry_idx = cert_list_add(&cert_list, cert_buf, cert_len);
+                    /* map cert-store index to cert-list entry index */
+                    cert_list_table[cert_table_idx] = cert_entry_idx;
+                    /* increment for the next certificate */
+                    cert_buf += cert_len;
+                }
+
+                comp_entry_info.cert_index = cert_list_table[cert_table_idx];
+                comp_entry_info.flags |= S390_IPL_DEV_COMP_FLAG_CSV;
+                puts("Verified component");
+            } else {
+                zipl_secure_error("Could not verify component");
+            }
+
+            comp_list_add(&comp_list, comp_entry_info);
+
+            signed_count += 1;
+            /* After a signature is used another new one can be accepted */
+            sig_entry_info.len = 0;
+            break;
+        default:

pc-bios/s390-ccw/secure-ipl.c line 346

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+            puts("Unknown component entry type");
+            return -1;
+        }
+
+        entry++;
+
+        if ((uint8_t *)(&entry[1]) > tmp_sec + MAX_SECTOR_SIZE) {
+            puts("Wrong entry value");
+            return -EINVAL;
+        }

For the two return cases above, should cert_buf be freed?

pc-bios/s390-ccw/secure-ipl.c line 359

Quoted 13 lines
pc-bios/s390-ccw/secure-ipl.c new file +13 -0
+    }
+
+    if (signed_count == 0) {
+        zipl_secure_error("Secure boot is on, but components are not signed");
+    }
+
+    update_iirb(&comp_list, &cert_list);
+
+    *entry_ptr = entry;
+    free((void *)sig_entry_info.addr);
+
+    return 0;
+out:

This is an error path, not out path.

Quoted 124 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+    free(cert_buf);
+    free((void *)sig_entry_info.addr);
+
+    return -1;
+}
pc-bios/s390-ccw/secure-ipl.h new file +113 -0
new file mode 100644
index 0000000000..cc0302f56b
@@ -0,0 +1,113 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef _PC_BIOS_S390_CCW_SECURE_IPL_H
+#define _PC_BIOS_S390_CCW_SECURE_IPL_H
+
+#include <diag320.h>
+#include <diag508.h>
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void);
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec);
+
+/* Custom struct for secure IPL component entry information */
+typedef struct SecureIplCompEntryInfo {
+    uint64_t addr;
+    uint64_t len;
+    uint16_t cert_index;
+    uint8_t  flags;
+} SecureIplCompEntryInfo;
+
+static inline void zipl_secure_error(const char *message)
+{
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        printf("AUDIT MODE WARNING: %s\n", message);
+        break;
+    default:
+        break;
+    }
+}
+
+static inline uint64_t _diag320(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x320\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_cert_store_facility_supported(void)
+{
+    uint32_t d320_ism;
+
+    if (!sclp_is_diag320_on()) {
+        return false;
+    }
+
+    if (_diag320(&d320_ism, DIAG_320_SUBC_QUERY_ISM) != DIAG_320_RC_OK) {
+        return false;
+    }
+
+    return d320_ism & (DIAG_320_ISM_QUERY_VCSI | DIAG_320_ISM_STORE_VC);
+}
+
+static inline uint64_t _diag508(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x508\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_signature_verif_supported(void)
+{
+    uint64_t d508_subcodes;
+
+    d508_subcodes = _diag508(NULL, DIAG_508_SUBC_QUERY_SUBC);
+    return d508_subcodes & DIAG_508_SUBC_SIG_VERIF;
+}
+
+static inline bool verify_signature(SecureIplCompEntryInfo comp_entry_info,
+                                    SecureIplCompEntryInfo sig_entry_info,
+                                    uint64_t *cert_len, uint8_t *cert_idx)
+{
+    Diag508SigVerifBlock svb;
+
+    svb.length = sizeof(Diag508SigVerifBlock);
+    svb.version = 0;
+    svb.comp_len = comp_entry_info.len;
+    svb.comp_addr = comp_entry_info.addr;
+    svb.sig_len = sig_entry_info.len;
+    svb.sig_addr = sig_entry_info.addr;
+
+    if (_diag508(&svb, DIAG_508_SUBC_SIG_VERIF) == DIAG_508_RC_OK) {
+        *cert_len = svb.cert_len;
+        /*
+         * DIAG 508 utilizes an index origin of 0 when indexing the cert store.
+         * The cert_idx will be used for DIAG 320 data structures, which expects
+         * an index origin of 1. Account for the offset here so it's easier to
+         * manage later.
+         */
+        *cert_idx = svb.cert_store_index + 1;
+        return true;
+    }
+
+    return false;
+}
+
+#endif /* _PC_BIOS_S390_CCW_SECURE_IPL_H */
Signature · 2 lines
Regards,
  Collin
#42 lore raw

Re: [PATCH v11 21/32] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

Quoted 11 lines · Collin Walling
Quoted 10 lines · Zhuoying Cai
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+        } vce;
+    } __attribute__((__aligned__(4096))) vcb = { 0 };
+
+    /* Get Verification Certificate Storage Size block with DIAG320 subcode 1 */
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }
+
+    /*
+     * Request single entry
Quoted 8 lines

pc-bios/s390-ccw/secure-ipl.c line 74

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+     * Fill input fields of single-entry VCB
+     *
+     * First and last index must be equal because only one
+     * VCE per VCB is currently supported
+     */

The last sentence is misleading because it seems like the DIAG 320 implementation *only* allows for a single VCE to be retrieved, but in reality it allows for a range of entries to be retrieved.

Yes, but no.  DIAG320 can, potentially, accept a range of indices and return a remaining verification certificate count (RVCC) if there is not enough memory to store the entire range in one VCB, however the implementation here does not provide any logic to handle a non-zero RVCC.  As such, only one VCE is supported per VCB in the current implementation.  Either additional logic needs to be added to support non-zero RVCC or we need this comment to note that only one VCE per VCB is, currently, supported.

Quoted 22 lines

pc-bios/s390-ccw/secure-ipl.c line 80

Quoted 7 lines
pc-bios/s390-ccw/secure-ipl.c new file +6 -0
+    vcb.vcb_hdr.in_len = ROUND_UP(vcssb.max_single_vcb_len, PAGE_SIZE);
+    vcb.vcb_hdr.first_vc_index = index;
+    vcb.vcb_hdr.last_vc_index = index;
+
+    if (_diag320(&vcb, DIAG_320_SUBC_STORE_VC) != DIAG_320_RC_OK) {
+        return 0;

Maybe move the puts("Could not get certificate"); to here so it's consistent with the other error cases?

pc-bios/s390-ccw/secure-ipl.c line 89

Quoted 9 lines
pc-bios/s390-ccw/secure-ipl.c new file +9 -0
+    }
+
+    if (vcb.vcb_hdr.out_len == sizeof(VCBlockHeader)) {
+        puts("No certificate entry");
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.remain_ct != 0) {
+        panic("Not enough memory to store all requested certificates");

Shouldn't this be "to store requested certificate" since this function aims to request only one cert?

Quoted 3 lines

Also, is there a reason for the panic? Why not just puts and return 0 like the rest? The program will still terminate, but a little more gracefully that way.

I agree that the message itself could be more clear, but the reason this is a panic is because it only triggers if the requested certificate is larger than the MAX_CERT_SIZE, which should never happen at this point (it would be caught earlier in the process when building the cert store I think). There should always be enough memory to hold at least one certificate, and only one certificate should ever be requested (due to the restriction above), so, if DIAG320 returns a non-zero RVCC it would indicate some sort of corruption in the cert store, which in my opinion should trigger an immediate panic.

Regards,
Jared Rossi

#43 lore raw

Re: [PATCH v11 21/32] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

In reply to Zhuoying Cai
Quoted 295 lines · Zhuoying Cai

Enable secure IPL in audit mode, which performs signature verification, but any error does not terminate the boot process. Only warnings will be logged to the console instead.

Add a comp_len variable to store the length of a segment in zipl_load_segment. comp_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities (Secure IPL Facility, Certificate Store Facility and secure IPL extension support).

Note: Secure IPL in audit mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
  docs/system/s390x/secure-ipl.rst |  15 ++
  pc-bios/s390-ccw/Makefile        |   2 +-
  pc-bios/s390-ccw/bootmap.c       |  16 ++
  pc-bios/s390-ccw/bootmap.h       |   9 +
  pc-bios/s390-ccw/main.c          |  10 +-
  pc-bios/s390-ccw/s390-ccw.h      |  24 ++
  pc-bios/s390-ccw/sclp.c          |  27 +++
  pc-bios/s390-ccw/sclp.h          |   6 +
  pc-bios/s390-ccw/secure-ipl.c    | 364 +++++++++++++++++++++++++++++++
  pc-bios/s390-ccw/secure-ipl.h    | 113 ++++++++++
  10 files changed, 584 insertions(+), 2 deletions(-)

create mode 100644 pc-bios/s390-ccw/secure-ipl.c create mode 100644 pc-bios/s390-ccw/secure-ipl.h

docs/system/s390x/secure-ipl.rst +15 -0
index 9d7d33f5ed..cf6ccf5d57 100644
@@ -39,3 +39,18 @@ Configuration:
  .. code-block:: shell
 
      qemu-system-s390x -machine s390-ccw-virtio ...
+
+Audit Mode
+^^^^^^^^^^
+
+When the certificate store is populated with at least one certificate
+and no additional secure IPL parameters are provided on the command
+line, then secure IPL will proceed in "audit mode". All secure IPL
+operations will be performed with signature verification errors reported
+as non-disruptive warnings.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/Makefile +1 -1
index 3e5dfb64d5..2109d16781 100644
@@ -35,7 +35,7 @@ QEMU_DGFLAGS = -MMD -MP -MT $@ -MF $(@D)/$(*F).d
 
  OBJECTS = start.o main.o bootmap.o jump2ipl.o sclp.o menu.o netmain.o \
  	  virtio.o virtio-net.o virtio-scsi.o virtio-blkdev.o cio.o dasd-ipl.o \
-	  virtio-ccw.o clp.o pci.o virtio-pci.o
+	  virtio-ccw.o clp.o pci.o virtio-pci.o secure-ipl.o
 
  SLOF_DIR := $(SRC_PATH)/../../roms/SLOF
 
pc-bios/s390-ccw/bootmap.c +16 -0
index 667a69f80d..a300fba8cd 100644
@@ -15,6 +15,7 @@
  #include "bootmap.h"
  #include "virtio.h"
  #include "bswap.h"
+#include "secure-ipl.h"
 
  #ifdef DEBUG
  /* #define DEBUG_FALLBACK */
@@ -737,6 +738,9 @@ static int zipl_run(ScsiBlockPtr *pte)
      case ZIPL_BOOT_MODE_NORMAL:
          rc = zipl_run_normal(&entry, tmp_sec);
          break;
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        rc = zipl_run_secure(&entry, tmp_sec);
+        break;
      default:
          panic("Unknown boot mode");
      }
@@ -1107,6 +1111,18 @@ static int zipl_load_vscsi(void)
   * IPL starts here
   */
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags)
+{
+    bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
+    bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+
+    if (!sipl_set && iplir_set) {
+        return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    }
+
+    return ZIPL_BOOT_MODE_NORMAL;
+}
+
  void zipl_load(void)
  {
      VDev *vdev = virtio_get_device();
pc-bios/s390-ccw/bootmap.h +9 -0
index 8d61ac383c..1e00454a1f 100644
@@ -88,9 +88,18 @@ typedef struct BootMapTable {
      BootMapPointer entry[];
  } __attribute__ ((packed)) BootMapTable;
 
+#define DER_SIGNATURE_FORMAT 1
+
+typedef struct SignatureInformation {
+    uint8_t format;
+    uint8_t reserved[3];
+    uint32_t sig_len;
+} SignatureInformation;
+
  typedef union ComponentEntryData {
      uint64_t load_psw;
      uint64_t load_addr;
+    SignatureInformation sig_info;
  } ComponentEntryData;
 
  typedef struct ComponentEntry {
pc-bios/s390-ccw/main.c +9 -1
index 66544f75f5..0bcd32b059 100644
@@ -394,7 +394,15 @@ void main(void)
          probe_boot_device();
      }
 
-    boot_mode = ZIPL_BOOT_MODE_NORMAL;
+    boot_mode = get_boot_mode(iplb->hdr_flags);
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        if (!secure_ipl_supported()) {
+            panic("Unable to boot in audit mode");
+        }
+    default:
+        break;
+    }
 
      while (have_iplb) {
          boot_setup();
pc-bios/s390-ccw/s390-ccw.h +24 -0
index 5420443ad2..b66a9b50bf 100644
@@ -40,6 +40,22 @@ typedef unsigned long long u64;
                              ((b) == 0 ? (a) : (MIN(a, b))))
  #endif
 
+/*
+ * Round number down to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_DOWN
+#define ROUND_DOWN(n, d) ((n) & -(0 ? (n) : (d)))
+#endif
+
+/*
+ * Round number up to multiple. Requires that d be a power of 2.
+ * Works even if d is a smaller type than n.
+ */
+#ifndef ROUND_UP
+#define ROUND_UP(n, d) ROUND_DOWN((n) + (d) - 1, (d))
+#endif
+
  #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
  #include "cio.h"
@@ -64,6 +80,8 @@ void sclp_print(const char *string);
  void sclp_set_write_mask(uint32_t receive_mask, uint32_t send_mask);
  void sclp_setup(void);
  void sclp_get_loadparm_ascii(char *loadparm);
+bool sclp_is_diag320_on(void);
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag);
  int sclp_read(char *str, size_t count);
 
  /* bootmap.c */
@@ -71,10 +89,16 @@ void zipl_load(void);
 
  typedef enum ZiplBootMode {
      ZIPL_BOOT_MODE_NORMAL = 0,
+    ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
  } ZiplBootMode;
 
  extern ZiplBootMode boot_mode;
 
+ZiplBootMode get_boot_mode(uint8_t hdr_flags);
+
+/* secure-ipl.c */
+bool secure_ipl_supported(void);
+
  /* jump2ipl.c */
  void write_reset_psw(uint64_t psw);
  int jump_to_IPL_code(uint64_t address);
pc-bios/s390-ccw/sclp.c +27 -0
index 4a07de018d..48bdfedf1f 100644
@@ -113,6 +113,33 @@ void sclp_get_loadparm_ascii(char *loadparm)
      }
  }
 
+bool sclp_is_diag320_on(void)
+{
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac134 & SCCB_FAC134_DIAG320_BIT;
+    }
+
+    return 0;
+}
+
+/* check if specified IPL facility flag is enabled */
+bool sclp_is_fac_ipl_flag_on(uint16_t fac_ipl_flag)
+{
+    ReadInfo *sccb = (void *)_sccb;
+
+    memset((char *)_sccb, 0, sizeof(ReadInfo));
+    sccb->h.length = SCCB_SIZE;
+    if (!sclp_service_call(SCLP_CMDW_READ_SCP_INFO, sccb)) {
+        return sccb->fac_ipl & fac_ipl_flag;
+    }
+
+    return 0;
+}
+
  int sclp_read(char *str, size_t count)
  {
      ReadEventData *sccb = (void *)_sccb;
pc-bios/s390-ccw/sclp.h +6 -0
index 64b53cad29..a8a41cd004 100644
@@ -50,6 +50,8 @@ typedef struct SCCBHeader {
  } __attribute__((packed)) SCCBHeader;
 
  #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
+#define SCCB_FAC134_DIAG320_BIT 0x4
+#define SCCB_FAC_IPL_SIPL_BIT   0x4000
 
  typedef struct ReadInfo {
      SCCBHeader h;
@@ -57,6 +59,10 @@ typedef struct ReadInfo {
      uint8_t rnsize;
      uint8_t reserved[13];
      uint8_t loadparm[LOADPARM_LEN];
+    uint8_t reserved1[102];
+    uint8_t fac134;
+    uint8_t reserved2;
+    uint16_t fac_ipl;
  } __attribute__((packed)) ReadInfo;
 
  typedef struct SCCB {
pc-bios/s390-ccw/secure-ipl.c new file +21 -0
new file mode 100644
index 0000000000..6e943446a7
@@ -0,0 +1,364 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Functions to support IPL in secure boot mode (DIAG 320, DIAG 508,
+ * signature verification, and certificate handling).
+ *
+ * For secure IPL overview: docs/system/s390x/secure-ipl.rst
+ * For secure IPL technical: docs/specs/s390x-secure-ipl.rst
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bootmap.h"
+#include "s390-ccw.h"
+#include "sclp.h"

pc-bios/s390-ccw/secure-ipl.c line 31

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+#include "secure-ipl.h"
+
+static VCStorageSizeBlock vcssb __attribute__((__aligned__(8)));
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void)
+{
+    /* avoid retrieving vcssb multiple times */
+    if (vcssb.length == VCSSB_MIN_LEN) {
+        return &vcssb;
+    }

I don't quite understand what is happening with the VCSSB_MIN_LENGTH here.  Why is the minimum length significant, as opposed to simply non-zero?

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+
+    vcssb.length = VCSSB_MIN_LEN;
+    if (_diag320(&vcssb, DIAG_320_SUBC_QUERY_VCSI) != DIAG_320_RC_OK) {
+        vcssb.length = 0;
+        return NULL;

pc-bios/s390-ccw/secure-ipl.c line 46

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+    }
+
+    return &vcssb;
+}
+
+static uint32_t get_total_certs_length(void)
+{
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }

Should we check if vcssb.len == 4 for the early return?  I think it designates an empty cert store and nothing else gets initialized.

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+
+    return vcssb.total_vcb_len - sizeof(VCBlockHeader) -
+           vcssb.total_vc_ct * sizeof(VCEntryHeader);
+}
+

pc-bios/s390-ccw/secure-ipl.c line 61

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+static uint32_t request_certificate(uint8_t *cert_buf, uint8_t index)
+{
+    VCEntryHeader *vce_hdr;
+    struct vcb {
+        VCBlockHeader vcb_hdr;
+        struct vce {
+            VCEntryHeader vce_hdr;
+            uint8_t cert_buf[CERT_BUF_MAX_LEN];
+        } vce;
+    } __attribute__((__aligned__(4096))) vcb = { 0 };

Regarding Collin's comments about using CERT_BUF_MAX_LEN versus vcssb.max_single_vcb_len, because the VCB must be 4k aligned we didn't want to malloc a variable length buffer, which is why the constant max was used.  AFAIK malloc cannot enforce any alignment requirements and we do not have the libraries for memalign in BIOS.

I thought I saw that the cert store does already reject certs exceeding this size, but if not, I agree with Collin that it should.

Quoted 40 lines
pc-bios/s390-ccw/secure-ipl.c new file +40 -0
+
+    /* Get Verification Certificate Storage Size block with DIAG320 subcode 1 */
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }
+
+    /*
+     * Request single entry
+     * Fill input fields of single-entry VCB
+     *
+     * First and last index must be equal because only one
+     * VCE per VCB is currently supported
+     */
+    vcb.vcb_hdr.in_len = ROUND_UP(vcssb.max_single_vcb_len, PAGE_SIZE);
+    vcb.vcb_hdr.first_vc_index = index;
+    vcb.vcb_hdr.last_vc_index = index;
+
+    if (_diag320(&vcb, DIAG_320_SUBC_STORE_VC) != DIAG_320_RC_OK) {
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.out_len == sizeof(VCBlockHeader)) {
+        puts("No certificate entry");
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.remain_ct != 0) {
+        panic("Not enough memory to store all requested certificates");
+    }
+
+    vce_hdr = &vcb.vce.vce_hdr;
+    if (!(vce_hdr->flags & DIAG_320_VCE_FLAGS_VALID)) {
+        puts("Invalid certificate");
+        return 0;
+    }
+
+    memcpy(cert_buf, (uint8_t *)&vcb.vce + vce_hdr->cert_offset, vce_hdr->cert_len);
+
+    return vce_hdr->cert_len;
+}

pc-bios/s390-ccw/secure-ipl.c line 111

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+
+static int cert_list_add(IplSignatureCertificateList *cert_list,
+                         uint8_t *cert_buf, uint64_t cert_len)
+{
+    static bool warned;
+    int cert_entry_idx;
+
+    cert_entry_idx = (cert_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplSignatureCertificateEntry);
+    if (cert_entry_idx > MAX_CERTIFICATES - 1) {

I think this is actually impossible because we terminate the IPL when building the cert store if there are too many entries, right?

Quoted 147 lines
pc-bios/s390-ccw/secure-ipl.c new file +147 -0
+        if (!warned) {
+            printf("Warning: only %d cert entries are supported;"
+                   " additional entries are ignored\n",
+                   MAX_CERTIFICATES);
+            warned = true;
+        }
+        return cert_entry_idx;
+    }
+
+    cert_list->cert_entries[cert_entry_idx].addr = (uint64_t)cert_buf;
+    cert_list->cert_entries[cert_entry_idx].len = cert_len;
+    cert_list->ipl_info_header.len += sizeof(IplSignatureCertificateEntry);
+
+    return cert_entry_idx;
+}
+
+static void comp_list_add(IplDeviceComponentList *comp_list,
+                          SecureIplCompEntryInfo comp_entry_info)
+{
+    int comp_entry_idx;
+
+    comp_entry_idx = (comp_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplDeviceComponentEntry);
+    if (comp_entry_idx > MAX_COMP_ENTRIES - 1) {
+        printf("Warning: only %d component entries are supported\n",
+                MAX_COMP_ENTRIES);
+        panic("The device component list has reached its maximum capacity");
+    }
+
+    comp_list->device_entries[comp_entry_idx].addr = comp_entry_info.addr;
+    comp_list->device_entries[comp_entry_idx].len = comp_entry_info.len;
+    comp_list->device_entries[comp_entry_idx].flags = comp_entry_info.flags;
+    /* cert index field is meaningful only when S390_IPL_DEV_COMP_FLAG_SC is set */
+    if (comp_entry_info.flags & S390_IPL_DEV_COMP_FLAG_SC) {
+        comp_list->device_entries[comp_entry_idx].cert_index =
+                                                  comp_entry_info.cert_index;
+    }
+    comp_list->ipl_info_header.len += sizeof(IplDeviceComponentEntry);
+}
+
+static void update_iirb(IplDeviceComponentList *comp_list,
+                        IplSignatureCertificateList *cert_list)
+{
+    IplInfoReportBlock *iirb;
+    IplDeviceComponentList *iirb_comps;
+    IplSignatureCertificateList *iirb_certs;
+    uint32_t iirb_hdr_len;
+    uint32_t comps_len;
+    uint32_t certs_len;
+
+    if (iplb->len % 8 != 0) {
+        panic("IPL parameter block length field value is not multiple of 8 bytes");
+    }
+
+    iirb_hdr_len = sizeof(IplInfoReportBlockHeader);
+    comps_len = comp_list->ipl_info_header.len;
+    certs_len = cert_list->ipl_info_header.len;
+    if ((comps_len + certs_len + iirb_hdr_len) > sizeof(IplInfoReportBlock)) {
+        panic("Not enough space to hold all components and certificates in IIRB");
+    }
+
+    /* IIRB immediately follows IPLB */
+    iirb = &ipl_data.iirb;
+    iirb->hdr.len = iirb_hdr_len;
+
+    /* Copy IPL device component list after IIRB Header */
+    iirb_comps = (IplDeviceComponentList *) iirb->info_blks;
+    memcpy(iirb_comps, comp_list, comps_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += comps_len;
+
+    /* Copy IPL sig cert list after IPL device component list */
+    iirb_certs = (IplSignatureCertificateList *) (iirb->info_blks +
+                                                  iirb_comps->ipl_info_header.len);
+    memcpy(iirb_certs, cert_list, certs_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += certs_len;
+}
+
+bool secure_ipl_supported(void)
+{
+    if (!sclp_is_fac_ipl_flag_on(SCCB_FAC_IPL_SIPL_BIT)) {
+        puts("Secure IPL Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_signature_verif_supported()) {
+        puts("Secure IPL extensions are not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_cert_store_facility_supported()) {
+        puts("Certificate Store Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    return true;
+}
+
+static void init_lists(IplDeviceComponentList *comp_list,
+                       IplSignatureCertificateList *cert_list)
+{
+    comp_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_COMPONENTS;
+    comp_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+
+    cert_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_CERTIFICATES;
+    cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+}
+
+static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
+{
+    if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
+        puts("Signature is not in DER format");
+        return -1;
+    }
+
+    if (zipl_load_segment(entry->data.blockno, sig) < 0) {
+        return -1;
+    }
+
+    return entry->compdat.sig_info.sig_len;
+}
+
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
+{
+    IplDeviceComponentList comp_list = { 0 };
+    IplSignatureCertificateList cert_list = { 0 };
+    SecureIplCompEntryInfo sig_entry_info = { 0 };
+    SecureIplCompEntryInfo comp_entry_info;
+    ComponentEntry *entry = *entry_ptr;
+    uint8_t *cert_buf = NULL;
+    int sig_len = 0;
+    int comp_len;
+    int cert_entry_idx;
+    uint64_t comp_addr;
+    uint64_t cert_len;
+    uint8_t cert_table_idx;
+    bool verified;
+    /*
+     * Keep track of which certificate store indices correspond to the
+     * certificate data entries within the IplSignatureCertificateList to
+     * prevent allocating space for the same certificate multiple times.
+     *
+     * The array index corresponds to the certificate's cert-store index.
+     *

pc-bios/s390-ccw/secure-ipl.c line 268

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+     * The array value corresponds to the certificate's entry within the
+     * IplSignatureCertificateList (with a value of -1 denoting no entry
+     * exists for the certificate).
+     */
+    int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
+    int signed_count = 0;
+
+    init_lists(&comp_list, &cert_list);
+    cert_buf = malloc(get_total_certs_length());
+    sig_entry_info.addr = (uint64_t)malloc(MAX_SECTOR_SIZE);

I think we can reduce the memory footprint significantly, which will also help with designating a safe spot for the components if we are worried about them getting clobbered or lost.

Currently cert_buf is allocating enough space for the entire cert store, but if I understand correctly, only 2 or possibly 3 certs can be used for any one IPL.  So I don't think it is necessary to allocate more than 3x the max cert size.

If we need a well defined place to put them, my first thought would be to use the "next_iplb" field of the qipl struct.  This field points to the next IPLB to be used when multiple boot devices are specified, but the address itself is derived as an offset from the start of the kernel code in memory.

There are 8 4K pages that can be used for chained IPLBs, but that space is no longer needed once we have identified our good IPLB and commit to booting it. I think this space can safely be used to store the certs until the kernel reads them during boot.

There might be a few other things that need adjustment, but in principle I think writing to the pages previously occupied by an IPLB chain should be viable.

Quoted 215 lines
pc-bios/s390-ccw/secure-ipl.c new file +96 -0
+
+    while (entry->component_type != ZIPL_COMP_ENTRY_EXEC) {
+        switch (entry->component_type) {
+        case ZIPL_COMP_ENTRY_SIGNATURE:
+            if (sig_entry_info.len) {
+                goto out;
+            }
+
+            sig_len = zipl_load_signature(entry, sig_entry_info.addr);
+            if (sig_len < 0) {
+                goto out;
+            }
+
+            sig_entry_info.len = sig_len;
+            break;
+        case ZIPL_COMP_ENTRY_LOAD:
+            comp_addr = entry->compdat.load_addr;
+            comp_len = zipl_load_segment(entry->data.blockno, comp_addr);
+            if (comp_len < 0) {
+                goto out;
+            }
+
+            comp_entry_info = (SecureIplCompEntryInfo){ 0 };
+            comp_entry_info.addr = comp_addr;
+            comp_entry_info.len = (uint64_t)comp_len;
+
+            /* no signature present (unsigned component) */
+            if (!sig_entry_info.len) {
+                break;
+            }
+
+            /*
+             * Initialize with SC flag (signed component)
+             * CSV flag set upon successful verification
+             */
+            comp_entry_info.flags = S390_IPL_DEV_COMP_FLAG_SC;
+
+            verified = verify_signature(comp_entry_info, sig_entry_info,
+                                        &cert_len, &cert_table_idx);
+
+            if (verified) {
+                if (cert_list_table[cert_table_idx] == -1) {
+                    if (!request_certificate(cert_buf, cert_table_idx)) {
+                        puts("Could not get certificate");
+                        goto out;
+                    }
+
+                    cert_entry_idx = cert_list_add(&cert_list, cert_buf, cert_len);
+                    /* map cert-store index to cert-list entry index */
+                    cert_list_table[cert_table_idx] = cert_entry_idx;
+                    /* increment for the next certificate */
+                    cert_buf += cert_len;
+                }
+
+                comp_entry_info.cert_index = cert_list_table[cert_table_idx];
+                comp_entry_info.flags |= S390_IPL_DEV_COMP_FLAG_CSV;
+                puts("Verified component");
+            } else {
+                zipl_secure_error("Could not verify component");
+            }
+
+            comp_list_add(&comp_list, comp_entry_info);
+
+            signed_count += 1;
+            /* After a signature is used another new one can be accepted */
+            sig_entry_info.len = 0;
+            break;
+        default:
+            puts("Unknown component entry type");
+            return -1;
+        }
+
+        entry++;
+
+        if ((uint8_t *)(&entry[1]) > tmp_sec + MAX_SECTOR_SIZE) {
+            puts("Wrong entry value");
+            return -EINVAL;
+        }
+    }
+
+    if (signed_count == 0) {
+        zipl_secure_error("Secure boot is on, but components are not signed");
+    }
+
+    update_iirb(&comp_list, &cert_list);
+
+    *entry_ptr = entry;
+    free((void *)sig_entry_info.addr);
+
+    return 0;
+out:
+    free(cert_buf);
+    free((void *)sig_entry_info.addr);
+
+    return -1;
+}
pc-bios/s390-ccw/secure-ipl.h new file +113 -0
new file mode 100644
index 0000000000..cc0302f56b
@@ -0,0 +1,113 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef _PC_BIOS_S390_CCW_SECURE_IPL_H
+#define _PC_BIOS_S390_CCW_SECURE_IPL_H
+
+#include <diag320.h>
+#include <diag508.h>
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void);
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec);
+
+/* Custom struct for secure IPL component entry information */
+typedef struct SecureIplCompEntryInfo {
+    uint64_t addr;
+    uint64_t len;
+    uint16_t cert_index;
+    uint8_t  flags;
+} SecureIplCompEntryInfo;
+
+static inline void zipl_secure_error(const char *message)
+{
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        printf("AUDIT MODE WARNING: %s\n", message);
+        break;
+    default:
+        break;
+    }
+}
+
+static inline uint64_t _diag320(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x320\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_cert_store_facility_supported(void)
+{
+    uint32_t d320_ism;
+
+    if (!sclp_is_diag320_on()) {
+        return false;
+    }
+
+    if (_diag320(&d320_ism, DIAG_320_SUBC_QUERY_ISM) != DIAG_320_RC_OK) {
+        return false;
+    }
+
+    return d320_ism & (DIAG_320_ISM_QUERY_VCSI | DIAG_320_ISM_STORE_VC);
+}
+
+static inline uint64_t _diag508(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x508\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_signature_verif_supported(void)
+{
+    uint64_t d508_subcodes;
+
+    d508_subcodes = _diag508(NULL, DIAG_508_SUBC_QUERY_SUBC);
+    return d508_subcodes & DIAG_508_SUBC_SIG_VERIF;
+}
+
+static inline bool verify_signature(SecureIplCompEntryInfo comp_entry_info,
+                                    SecureIplCompEntryInfo sig_entry_info,
+                                    uint64_t *cert_len, uint8_t *cert_idx)
+{
+    Diag508SigVerifBlock svb;
+
+    svb.length = sizeof(Diag508SigVerifBlock);
+    svb.version = 0;
+    svb.comp_len = comp_entry_info.len;
+    svb.comp_addr = comp_entry_info.addr;
+    svb.sig_len = sig_entry_info.len;
+    svb.sig_addr = sig_entry_info.addr;
+
+    if (_diag508(&svb, DIAG_508_SUBC_SIG_VERIF) == DIAG_508_RC_OK) {
+        *cert_len = svb.cert_len;
+        /*
+         * DIAG 508 utilizes an index origin of 0 when indexing the cert store.
+         * The cert_idx will be used for DIAG 320 data structures, which expects
+         * an index origin of 1. Account for the offset here so it's easier to
+         * manage later.
+         */
+        *cert_idx = svb.cert_store_index + 1;
+        return true;
+    }
+
+    return false;
+}
+
+#endif /* _PC_BIOS_S390_CCW_SECURE_IPL_H */
#44 lore raw

Re: [PATCH v11 21/32] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

Thanks for the feedback and suggestion!

Quoted 35 lines · Jared Rossi
Quoted 32 lines · Zhuoying Cai

Enable secure IPL in audit mode, which performs signature verification, but any error does not terminate the boot process. Only warnings will be logged to the console instead.

Add a comp_len variable to store the length of a segment in zipl_load_segment. comp_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities (Secure IPL Facility, Certificate Store Facility and secure IPL extension support).

Note: Secure IPL in audit mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
  docs/system/s390x/secure-ipl.rst |  15 ++
  pc-bios/s390-ccw/Makefile        |   2 +-
  pc-bios/s390-ccw/bootmap.c       |  16 ++
  pc-bios/s390-ccw/bootmap.h       |   9 +
  pc-bios/s390-ccw/main.c          |  10 +-
  pc-bios/s390-ccw/s390-ccw.h      |  24 ++
  pc-bios/s390-ccw/sclp.c          |  27 +++
  pc-bios/s390-ccw/sclp.h          |   6 +
  pc-bios/s390-ccw/secure-ipl.c    | 364 +++++++++++++++++++++++++++++++
  pc-bios/s390-ccw/secure-ipl.h    | 113 ++++++++++
  10 files changed, 584 insertions(+), 2 deletions(-)

create mode 100644 pc-bios/s390-ccw/secure-ipl.c create mode 100644 pc-bios/s390-ccw/secure-ipl.h

[...]

Quoted 32 lines
Quoted 32 lines
pc-bios/s390-ccw/secure-ipl.c new file +26 -0
new file mode 100644
index 0000000000..6e943446a7
@@ -0,0 +1,364 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Functions to support IPL in secure boot mode (DIAG 320, DIAG 508,
+ * signature verification, and certificate handling).
+ *
+ * For secure IPL overview: docs/system/s390x/secure-ipl.rst
+ * For secure IPL technical: docs/specs/s390x-secure-ipl.rst
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bootmap.h"
+#include "s390-ccw.h"
+#include "sclp.h"
+#include "secure-ipl.h"
+
+static VCStorageSizeBlock vcssb __attribute__((__aligned__(8)));
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void)
Quoted 9 lines

pc-bios/s390-ccw/secure-ipl.c line 31

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+{
+    /* avoid retrieving vcssb multiple times */
+    if (vcssb.length == VCSSB_MIN_LEN) {
+        return &vcssb;
+    }

I don't quite understand what is happening with the VCSSB_MIN_LENGTH here.  Why
is the minimum length significant, as opposed to simply non-zero?

VCSSB must be set to VCSSB_MIN_LENGTH (128), as this represents the size of the VCSSB struct and indicates that it is present. Any other value would be considered an invalid length for VCSSB.

To avoid confusion, we could consider renaming VCSSB_MIN_LENGTH to VCSSB_LEN.

Quoted 10 lines
Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+
+    vcssb.length = VCSSB_MIN_LEN;
+    if (_diag320(&vcssb, DIAG_320_SUBC_QUERY_VCSI) != DIAG_320_RC_OK) {
+        vcssb.length = 0;
+        return NULL;
+    }
+
+    return &vcssb;
+}
+
Quoted 9 lines

pc-bios/s390-ccw/secure-ipl.c line 46

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+static uint32_t get_total_certs_length(void)
+{
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }

Should we check if vcssb.len == 4 for the early return?  I think it designates
an empty cert store and nothing else gets initialized.

Yes, this check is currently in [PATCH v11 27/32] pc-bios/s390-ccw:
Handle true secure IPL mode. I’ll refactor it so it can be performed earlier during the secure boot process.

Quoted 23 lines
Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+
+    return vcssb.total_vcb_len - sizeof(VCBlockHeader) -
+           vcssb.total_vc_ct * sizeof(VCEntryHeader);
+}
+

pc-bios/s390-ccw/secure-ipl.c line 61

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+static uint32_t request_certificate(uint8_t *cert_buf, uint8_t index)
+{
+    VCEntryHeader *vce_hdr;
+    struct vcb {
+        VCBlockHeader vcb_hdr;
+        struct vce {
+            VCEntryHeader vce_hdr;
+            uint8_t cert_buf[CERT_BUF_MAX_LEN];
+        } vce;
+    } __attribute__((__aligned__(4096))) vcb = { 0 };

Regarding Collin's comments about using CERT_BUF_MAX_LEN versus vcssb.max_single_vcb_len,
because the VCB must be 4k aligned we didn't want to malloc a variable length
buffer, which is why the constant max was used.  AFAIK malloc cannot enforce any alignment requirements and we do not have the libraries for memalign in BIOS.

Quoted 4 lines

I thought I saw that the cert store does already reject certs exceeding this size,
but if not, I agree with Collin that it should.

Maybe we could use vcssb.max_single_vcb_len - sizeof(VCBlockHeader) - sizeof(VCEntryHeader) instead of CERT_BUF_MAX_LEN when sizing cert_buf.

The cert store already rejects anything larger than CERT_BUF_MAX_LEN, so the requested size is guaranteed to stay within bounds.

Since vcssb.max_single_vcb_len is also used as the input length for the VCB, basing cert_buf on it would make the buffer size more accurate.

Does this sound reasonable to you?

Quoted 457 lines
Quoted 40 lines
pc-bios/s390-ccw/secure-ipl.c new file +40 -0
+
+    /* Get Verification Certificate Storage Size block with DIAG320 subcode 1 */
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }
+
+    /*
+     * Request single entry
+     * Fill input fields of single-entry VCB
+     *
+     * First and last index must be equal because only one
+     * VCE per VCB is currently supported
+     */
+    vcb.vcb_hdr.in_len = ROUND_UP(vcssb.max_single_vcb_len, PAGE_SIZE);
+    vcb.vcb_hdr.first_vc_index = index;
+    vcb.vcb_hdr.last_vc_index = index;
+
+    if (_diag320(&vcb, DIAG_320_SUBC_STORE_VC) != DIAG_320_RC_OK) {
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.out_len == sizeof(VCBlockHeader)) {
+        puts("No certificate entry");
+        return 0;
+    }
+
+    if (vcb.vcb_hdr.remain_ct != 0) {
+        panic("Not enough memory to store all requested certificates");
+    }
+
+    vce_hdr = &vcb.vce.vce_hdr;
+    if (!(vce_hdr->flags & DIAG_320_VCE_FLAGS_VALID)) {
+        puts("Invalid certificate");
+        return 0;
+    }
+
+    memcpy(cert_buf, (uint8_t *)&vcb.vce + vce_hdr->cert_offset, vce_hdr->cert_len);
+
+    return vce_hdr->cert_len;
+}

pc-bios/s390-ccw/secure-ipl.c line 111

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+
+static int cert_list_add(IplSignatureCertificateList *cert_list,
+                         uint8_t *cert_buf, uint64_t cert_len)
+{
+    static bool warned;
+    int cert_entry_idx;
+
+    cert_entry_idx = (cert_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplSignatureCertificateEntry);
+    if (cert_entry_idx > MAX_CERTIFICATES - 1) {

I think this is actually impossible because we terminate the IPL when building
the cert store if there are too many entries, right?

Quoted 147 lines
pc-bios/s390-ccw/secure-ipl.c new file +147 -0
+        if (!warned) {
+            printf("Warning: only %d cert entries are supported;"
+                   " additional entries are ignored\n",
+                   MAX_CERTIFICATES);
+            warned = true;
+        }
+        return cert_entry_idx;
+    }
+
+    cert_list->cert_entries[cert_entry_idx].addr = (uint64_t)cert_buf;
+    cert_list->cert_entries[cert_entry_idx].len = cert_len;
+    cert_list->ipl_info_header.len += sizeof(IplSignatureCertificateEntry);
+
+    return cert_entry_idx;
+}
+
+static void comp_list_add(IplDeviceComponentList *comp_list,
+                          SecureIplCompEntryInfo comp_entry_info)
+{
+    int comp_entry_idx;
+
+    comp_entry_idx = (comp_list->ipl_info_header.len - sizeof(IplInfoBlockHeader)) /
+                     sizeof(IplDeviceComponentEntry);
+    if (comp_entry_idx > MAX_COMP_ENTRIES - 1) {
+        printf("Warning: only %d component entries are supported\n",
+                MAX_COMP_ENTRIES);
+        panic("The device component list has reached its maximum capacity");
+    }
+
+    comp_list->device_entries[comp_entry_idx].addr = comp_entry_info.addr;
+    comp_list->device_entries[comp_entry_idx].len = comp_entry_info.len;
+    comp_list->device_entries[comp_entry_idx].flags = comp_entry_info.flags;
+    /* cert index field is meaningful only when S390_IPL_DEV_COMP_FLAG_SC is set */
+    if (comp_entry_info.flags & S390_IPL_DEV_COMP_FLAG_SC) {
+        comp_list->device_entries[comp_entry_idx].cert_index =
+                                                  comp_entry_info.cert_index;
+    }
+    comp_list->ipl_info_header.len += sizeof(IplDeviceComponentEntry);
+}
+
+static void update_iirb(IplDeviceComponentList *comp_list,
+                        IplSignatureCertificateList *cert_list)
+{
+    IplInfoReportBlock *iirb;
+    IplDeviceComponentList *iirb_comps;
+    IplSignatureCertificateList *iirb_certs;
+    uint32_t iirb_hdr_len;
+    uint32_t comps_len;
+    uint32_t certs_len;
+
+    if (iplb->len % 8 != 0) {
+        panic("IPL parameter block length field value is not multiple of 8 bytes");
+    }
+
+    iirb_hdr_len = sizeof(IplInfoReportBlockHeader);
+    comps_len = comp_list->ipl_info_header.len;
+    certs_len = cert_list->ipl_info_header.len;
+    if ((comps_len + certs_len + iirb_hdr_len) > sizeof(IplInfoReportBlock)) {
+        panic("Not enough space to hold all components and certificates in IIRB");
+    }
+
+    /* IIRB immediately follows IPLB */
+    iirb = &ipl_data.iirb;
+    iirb->hdr.len = iirb_hdr_len;
+
+    /* Copy IPL device component list after IIRB Header */
+    iirb_comps = (IplDeviceComponentList *) iirb->info_blks;
+    memcpy(iirb_comps, comp_list, comps_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += comps_len;
+
+    /* Copy IPL sig cert list after IPL device component list */
+    iirb_certs = (IplSignatureCertificateList *) (iirb->info_blks +
+                                                  iirb_comps->ipl_info_header.len);
+    memcpy(iirb_certs, cert_list, certs_len);
+
+    /* Update IIRB length */
+    iirb->hdr.len += certs_len;
+}
+
+bool secure_ipl_supported(void)
+{
+    if (!sclp_is_fac_ipl_flag_on(SCCB_FAC_IPL_SIPL_BIT)) {
+        puts("Secure IPL Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_signature_verif_supported()) {
+        puts("Secure IPL extensions are not supported by the hypervisor!");
+        return false;
+    }
+
+    if (!is_cert_store_facility_supported()) {
+        puts("Certificate Store Facility is not supported by the hypervisor!");
+        return false;
+    }
+
+    return true;
+}
+
+static void init_lists(IplDeviceComponentList *comp_list,
+                       IplSignatureCertificateList *cert_list)
+{
+    comp_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_COMPONENTS;
+    comp_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+
+    cert_list->ipl_info_header.type = IPL_INFO_BLOCK_TYPE_CERTIFICATES;
+    cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
+}
+
+static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
+{
+    if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
+        puts("Signature is not in DER format");
+        return -1;
+    }
+
+    if (zipl_load_segment(entry->data.blockno, sig) < 0) {
+        return -1;
+    }
+
+    return entry->compdat.sig_info.sig_len;
+}
+
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
+{
+    IplDeviceComponentList comp_list = { 0 };
+    IplSignatureCertificateList cert_list = { 0 };
+    SecureIplCompEntryInfo sig_entry_info = { 0 };
+    SecureIplCompEntryInfo comp_entry_info;
+    ComponentEntry *entry = *entry_ptr;
+    uint8_t *cert_buf = NULL;
+    int sig_len = 0;
+    int comp_len;
+    int cert_entry_idx;
+    uint64_t comp_addr;
+    uint64_t cert_len;
+    uint8_t cert_table_idx;
+    bool verified;
+    /*
+     * Keep track of which certificate store indices correspond to the
+     * certificate data entries within the IplSignatureCertificateList to
+     * prevent allocating space for the same certificate multiple times.
+     *
+     * The array index corresponds to the certificate's cert-store index.
+     *

pc-bios/s390-ccw/secure-ipl.c line 268

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+     * The array value corresponds to the certificate's entry within the
+     * IplSignatureCertificateList (with a value of -1 denoting no entry
+     * exists for the certificate).
+     */
+    int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
+    int signed_count = 0;
+
+    init_lists(&comp_list, &cert_list);
+    cert_buf = malloc(get_total_certs_length());
+    sig_entry_info.addr = (uint64_t)malloc(MAX_SECTOR_SIZE);

I think we can reduce the memory footprint significantly, which will also help
with designating a safe spot for the components if we are worried about them getting clobbered or lost.

Currently cert_buf is allocating enough space for the entire cert store, but if I understand correctly, only 2 or possibly 3 certs can be used for any one
IPL.  So I don't think it is necessary to allocate more than 3x the max cert size.

If we need a well defined place to put them, my first thought would be to use
the "next_iplb" field of the qipl struct.  This field points to the next IPLB
to be used when multiple boot devices are specified, but the address itself is
derived as an offset from the start of the kernel code in memory.

There are 8 4K pages that can be used for chained IPLBs, but that space is no
longer needed once we have identified our good IPLB and commit to booting it.
I think this space can safely be used to store the certs until the kernel reads them during boot.

There might be a few other things that need adjustment, but in principle I think
writing to the pages previously occupied by an IPLB chain should be viable.

Quoted 215 lines
pc-bios/s390-ccw/secure-ipl.c new file +96 -0
+
+    while (entry->component_type != ZIPL_COMP_ENTRY_EXEC) {
+        switch (entry->component_type) {
+        case ZIPL_COMP_ENTRY_SIGNATURE:
+            if (sig_entry_info.len) {
+                goto out;
+            }
+
+            sig_len = zipl_load_signature(entry, sig_entry_info.addr);
+            if (sig_len < 0) {
+                goto out;
+            }
+
+            sig_entry_info.len = sig_len;
+            break;
+        case ZIPL_COMP_ENTRY_LOAD:
+            comp_addr = entry->compdat.load_addr;
+            comp_len = zipl_load_segment(entry->data.blockno, comp_addr);
+            if (comp_len < 0) {
+                goto out;
+            }
+
+            comp_entry_info = (SecureIplCompEntryInfo){ 0 };
+            comp_entry_info.addr = comp_addr;
+            comp_entry_info.len = (uint64_t)comp_len;
+
+            /* no signature present (unsigned component) */
+            if (!sig_entry_info.len) {
+                break;
+            }
+
+            /*
+             * Initialize with SC flag (signed component)
+             * CSV flag set upon successful verification
+             */
+            comp_entry_info.flags = S390_IPL_DEV_COMP_FLAG_SC;
+
+            verified = verify_signature(comp_entry_info, sig_entry_info,
+                                        &cert_len, &cert_table_idx);
+
+            if (verified) {
+                if (cert_list_table[cert_table_idx] == -1) {
+                    if (!request_certificate(cert_buf, cert_table_idx)) {
+                        puts("Could not get certificate");
+                        goto out;
+                    }
+
+                    cert_entry_idx = cert_list_add(&cert_list, cert_buf, cert_len);
+                    /* map cert-store index to cert-list entry index */
+                    cert_list_table[cert_table_idx] = cert_entry_idx;
+                    /* increment for the next certificate */
+                    cert_buf += cert_len;
+                }
+
+                comp_entry_info.cert_index = cert_list_table[cert_table_idx];
+                comp_entry_info.flags |= S390_IPL_DEV_COMP_FLAG_CSV;
+                puts("Verified component");
+            } else {
+                zipl_secure_error("Could not verify component");
+            }
+
+            comp_list_add(&comp_list, comp_entry_info);
+
+            signed_count += 1;
+            /* After a signature is used another new one can be accepted */
+            sig_entry_info.len = 0;
+            break;
+        default:
+            puts("Unknown component entry type");
+            return -1;
+        }
+
+        entry++;
+
+        if ((uint8_t *)(&entry[1]) > tmp_sec + MAX_SECTOR_SIZE) {
+            puts("Wrong entry value");
+            return -EINVAL;
+        }
+    }
+
+    if (signed_count == 0) {
+        zipl_secure_error("Secure boot is on, but components are not signed");
+    }
+
+    update_iirb(&comp_list, &cert_list);
+
+    *entry_ptr = entry;
+    free((void *)sig_entry_info.addr);
+
+    return 0;
+out:
+    free(cert_buf);
+    free((void *)sig_entry_info.addr);
+
+    return -1;
+}
pc-bios/s390-ccw/secure-ipl.h new file +113 -0
new file mode 100644
index 0000000000..cc0302f56b
@@ -0,0 +1,113 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef _PC_BIOS_S390_CCW_SECURE_IPL_H
+#define _PC_BIOS_S390_CCW_SECURE_IPL_H
+
+#include <diag320.h>
+#include <diag508.h>
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void);
+int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec);
+
+/* Custom struct for secure IPL component entry information */
+typedef struct SecureIplCompEntryInfo {
+    uint64_t addr;
+    uint64_t len;
+    uint16_t cert_index;
+    uint8_t  flags;
+} SecureIplCompEntryInfo;
+
+static inline void zipl_secure_error(const char *message)
+{
+    switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE_AUDIT:
+        printf("AUDIT MODE WARNING: %s\n", message);
+        break;
+    default:
+        break;
+    }
+}
+
+static inline uint64_t _diag320(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x320\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_cert_store_facility_supported(void)
+{
+    uint32_t d320_ism;
+
+    if (!sclp_is_diag320_on()) {
+        return false;
+    }
+
+    if (_diag320(&d320_ism, DIAG_320_SUBC_QUERY_ISM) != DIAG_320_RC_OK) {
+        return false;
+    }
+
+    return d320_ism & (DIAG_320_ISM_QUERY_VCSI | DIAG_320_ISM_STORE_VC);
+}
+
+static inline uint64_t _diag508(void *data, unsigned long subcode)
+{
+    register unsigned long addr asm("0") = (unsigned long)data;
+    register unsigned long rc asm("1") = 0;
+
+    asm volatile ("diag %0,%2,0x508\n"
+                  : "+d" (addr), "+d" (rc)
+                  : "d" (subcode)
+                  : "memory", "cc");
+    return rc;
+}
+
+static inline bool is_signature_verif_supported(void)
+{
+    uint64_t d508_subcodes;
+
+    d508_subcodes = _diag508(NULL, DIAG_508_SUBC_QUERY_SUBC);
+    return d508_subcodes & DIAG_508_SUBC_SIG_VERIF;
+}
+
+static inline bool verify_signature(SecureIplCompEntryInfo comp_entry_info,
+                                    SecureIplCompEntryInfo sig_entry_info,
+                                    uint64_t *cert_len, uint8_t *cert_idx)
+{
+    Diag508SigVerifBlock svb;
+
+    svb.length = sizeof(Diag508SigVerifBlock);
+    svb.version = 0;
+    svb.comp_len = comp_entry_info.len;
+    svb.comp_addr = comp_entry_info.addr;
+    svb.sig_len = sig_entry_info.len;
+    svb.sig_addr = sig_entry_info.addr;
+
+    if (_diag508(&svb, DIAG_508_SUBC_SIG_VERIF) == DIAG_508_RC_OK) {
+        *cert_len = svb.cert_len;
+        /*
+         * DIAG 508 utilizes an index origin of 0 when indexing the cert store.
+         * The cert_idx will be used for DIAG 320 data structures, which expects
+         * an index origin of 1. Account for the offset here so it's easier to
+         * manage later.
+         */
+        *cert_idx = svb.cert_store_index + 1;
+        return true;
+    }
+
+    return false;
+}
+
+#endif /* _PC_BIOS_S390_CCW_SECURE_IPL_H */
#45 lore raw

Re: [PATCH v11 21/32] pc-bios/s390-ccw: Add signature verification for secure IPL in audit mode

Quoted 80 lines · Zhuoying Cai

Thanks for the feedback and suggestion!

Quoted 34 lines · Jared Rossi
Quoted 32 lines · Zhuoying Cai

Enable secure IPL in audit mode, which performs signature verification, but any error does not terminate the boot process. Only warnings will be logged to the console instead.

Add a comp_len variable to store the length of a segment in zipl_load_segment. comp_len variable is necessary to store the calculated segment length and is used during signature verification. Return the length on success, or a negative return code on failure.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities (Secure IPL Facility, Certificate Store Facility and secure IPL extension support).

Note: Secure IPL in audit mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
   docs/system/s390x/secure-ipl.rst |  15 ++
   pc-bios/s390-ccw/Makefile        |   2 +-
   pc-bios/s390-ccw/bootmap.c       |  16 ++
   pc-bios/s390-ccw/bootmap.h       |   9 +
   pc-bios/s390-ccw/main.c          |  10 +-
   pc-bios/s390-ccw/s390-ccw.h      |  24 ++
   pc-bios/s390-ccw/sclp.c          |  27 +++
   pc-bios/s390-ccw/sclp.h          |   6 +
   pc-bios/s390-ccw/secure-ipl.c    | 364 +++++++++++++++++++++++++++++++
   pc-bios/s390-ccw/secure-ipl.h    | 113 ++++++++++
   10 files changed, 584 insertions(+), 2 deletions(-)

create mode 100644 pc-bios/s390-ccw/secure-ipl.c create mode 100644 pc-bios/s390-ccw/secure-ipl.h

[...]

Quoted 32 lines
Quoted 32 lines
pc-bios/s390-ccw/secure-ipl.c new file +26 -0
new file mode 100644
index 0000000000..6e943446a7
@@ -0,0 +1,364 @@
+/*
+ * S/390 Secure IPL
+ *
+ * Functions to support IPL in secure boot mode (DIAG 320, DIAG 508,
+ * signature verification, and certificate handling).
+ *
+ * For secure IPL overview: docs/system/s390x/secure-ipl.rst
+ * For secure IPL technical: docs/specs/s390x-secure-ipl.rst
+ *
+ * Copyright 2025 IBM Corp.
+ * Author(s): Zhuoying Cai <[email protected]>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bootmap.h"
+#include "s390-ccw.h"
+#include "sclp.h"
+#include "secure-ipl.h"
+
+static VCStorageSizeBlock vcssb __attribute__((__aligned__(8)));
+
+VCStorageSizeBlock *zipl_secure_get_vcssb(void)
Quoted 9 lines

pc-bios/s390-ccw/secure-ipl.c line 31

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+{
+    /* avoid retrieving vcssb multiple times */
+    if (vcssb.length == VCSSB_MIN_LEN) {
+        return &vcssb;
+    }

I don't quite understand what is happening with the VCSSB_MIN_LENGTH here.  Why
is the minimum length significant, as opposed to simply non-zero?

Quoted 6 lines

VCSSB must be set to VCSSB_MIN_LENGTH (128), as this represents the size of the VCSSB struct and indicates that it is present. Any other value would be considered an invalid length for VCSSB.

To avoid confusion, we could consider renaming VCSSB_MIN_LENGTH to VCSSB_LEN.

Maybe it could be VCSSB_LEN_VALID?  This would make it more clear that it is a specific size we expect that any valid VCSSB will conform to.

Quoted 54 lines
Quoted 11 lines
Quoted 11 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+
+    vcssb.length = VCSSB_MIN_LEN;
+    if (_diag320(&vcssb, DIAG_320_SUBC_QUERY_VCSI) != DIAG_320_RC_OK) {
+        vcssb.length = 0;
+        return NULL;
+    }
+
+    return &vcssb;
+}
+
Quoted 9 lines

pc-bios/s390-ccw/secure-ipl.c line 46

Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+static uint32_t get_total_certs_length(void)
+{
+    if (zipl_secure_get_vcssb() == NULL) {
+        return 0;
+    }

Should we check if vcssb.len == 4 for the early return?  I think it designates
an empty cert store and nothing else gets initialized.

Yes, this check is currently in [PATCH v11 27/32] pc-bios/s390-ccw:
Handle true secure IPL mode. I’ll refactor it so it can be performed earlier during the secure boot process.

Quoted 23 lines
Quoted 5 lines
pc-bios/s390-ccw/secure-ipl.c new file +5 -0
+
+    return vcssb.total_vcb_len - sizeof(VCBlockHeader) -
+           vcssb.total_vc_ct * sizeof(VCEntryHeader);
+}
+

pc-bios/s390-ccw/secure-ipl.c line 61

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c new file +10 -0
+static uint32_t request_certificate(uint8_t *cert_buf, uint8_t index)
+{
+    VCEntryHeader *vce_hdr;
+    struct vcb {
+        VCBlockHeader vcb_hdr;
+        struct vce {
+            VCEntryHeader vce_hdr;
+            uint8_t cert_buf[CERT_BUF_MAX_LEN];
+        } vce;
+    } __attribute__((__aligned__(4096))) vcb = { 0 };

Regarding Collin's comments about using CERT_BUF_MAX_LEN versus vcssb.max_single_vcb_len,
because the VCB must be 4k aligned we didn't want to malloc a variable length
buffer, which is why the constant max was used.  AFAIK malloc cannot enforce any alignment requirements and we do not have the libraries for memalign in BIOS.

Quoted 4 lines

I thought I saw that the cert store does already reject certs exceeding this size,
but if not, I agree with Collin that it should.

Maybe we could use vcssb.max_single_vcb_len - sizeof(VCBlockHeader) - sizeof(VCEntryHeader) instead of CERT_BUF_MAX_LEN when sizing cert_buf.

Quoted 7 lines

The cert store already rejects anything larger than CERT_BUF_MAX_LEN, so the requested size is guaranteed to stay within bounds.

Since vcssb.max_single_vcb_len is also used as the input length for the VCB, basing cert_buf on it would make the buffer size more accurate.

Does this sound reasonable to you?

Isn't the objective of using static allocation to make the 4K alignment easier?  I'm not strictly opposed to using dynamic sizing, but it seems to add a lot of complexity for only a little benefit.  You are correct that using the max size will have some excess space allocated, but this is just a temporary buffer, right?  The data the IIRB points and what the kernel reads will be the correct size in the end.

Regards,
Jared Rossi

#46 lore raw

PATCH v11 22/32 pc-bios/s390-ccw: Add signed component address overlap checks

In reply to Zhuoying Cai

Add address range tracking and overlap checks to ensure that no component overlaps with a signed component during secure IPL.

---
 pc-bios/s390-ccw/secure-ipl.c | 49 +++++++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h | 15 +++++++++++
 2 files changed, 64 insertions(+)
pc-bios/s390-ccw/secure-ipl.c +49 -0
index 6e943446a7..fdac74aa97 100644
@@ -220,6 +220,51 @@ static void init_lists(IplDeviceComponentList *comp_list,
     cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
 }
 
+static void check_comp_overlap(SecureIplCompAddrRangeList *range_list,
+                               SecureIplCompEntryInfo comp_entry_info)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    /*
+     * Check component's address range does not overlap with any
+     * signed component's address range.
+     */
+    for (int i = 0; i < range_list->num; i++) {
+        if (range_list->comp_addr_range[i].is_signed &&
+            (range_list->comp_addr_range[i].start_addr < end_addr &&
+            start_addr < range_list->comp_addr_range[i].end_addr)) {
+            zipl_secure_error("Component addresses overlap");
+       }
+    }
+}
+
+static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list,
+                                SecureIplCompEntryInfo comp_entry_info,
+                                bool is_signed)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    if (range_list->num >= MAX_COMP_ENTRIES) {
+        zipl_secure_error("Component address range update failed due to out-of-range"
+                          " index; Overlapping validation cannot be guaranteed");
+        return;
+    }
+
+    range_list->comp_addr_range[range_list->num].is_signed = is_signed;
+    range_list->comp_addr_range[range_list->num].start_addr = start_addr;
+    range_list->comp_addr_range[range_list->num].end_addr = end_addr;
+
+    range_list->num += 1;
+}
+
 static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
 {
     if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
@@ -261,6 +306,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
      * exists for the certificate).
      */
     int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
+    SecureIplCompAddrRangeList range_list = { 0 };
     int signed_count = 0;
 
     init_lists(&comp_list, &cert_list);
@@ -292,6 +338,9 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
             comp_entry_info.addr = comp_addr;
             comp_entry_info.len = (uint64_t)comp_len;
 
+            check_comp_overlap(&range_list, comp_entry_info);
+            comp_addr_range_add(&range_list, comp_entry_info, !!sig_len);
+
             /* no signature present (unsigned component) */
             if (!sig_entry_info.len) {
                 break;
pc-bios/s390-ccw/secure-ipl.h +15 -0
index cc0302f56b..29bbf65c6c 100644
@@ -24,6 +24,21 @@ typedef struct SecureIplCompEntryInfo {
     uint8_t  flags;
 } SecureIplCompEntryInfo;
 
+typedef struct SecureIplCompAddrRange {
+    bool is_signed;
+    uint64_t start_addr;
+    uint64_t end_addr;
+} SecureIplCompAddrRange;
+
+/*
+ * Custom struct for managing a list of secure IPL component address ranges.
+ * Tracks up to MAX_COMP_ENTRIES address ranges with an num counter.
+ */
+typedef struct SecureIplCompAddrRangeList {
+    SecureIplCompAddrRange comp_addr_range[MAX_COMP_ENTRIES];
+    int num;
+} SecureIplCompAddrRangeList;
+
 static inline void zipl_secure_error(const char *message)
 {
     switch (boot_mode) {
Signature · 1 line
2.54.0
#47 lore raw

Re: [PATCH v11 22/32] pc-bios/s390-ccw: Add signed component address overlap checks

Quoted 99 lines · Zhuoying Cai

Add address range tracking and overlap checks to ensure that no component overlaps with a signed component during secure IPL.

---
 pc-bios/s390-ccw/secure-ipl.c | 49 +++++++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h | 15 +++++++++++
 2 files changed, 64 insertions(+)
pc-bios/s390-ccw/secure-ipl.c +49 -0
index 6e943446a7..fdac74aa97 100644
@@ -220,6 +220,51 @@ static void init_lists(IplDeviceComponentList *comp_list,
     cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
 }
 
+static void check_comp_overlap(SecureIplCompAddrRangeList *range_list,
+                               SecureIplCompEntryInfo comp_entry_info)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    /*
+     * Check component's address range does not overlap with any
+     * signed component's address range.
+     */
+    for (int i = 0; i < range_list->num; i++) {
+        if (range_list->comp_addr_range[i].is_signed &&
+            (range_list->comp_addr_range[i].start_addr < end_addr &&
+            start_addr < range_list->comp_addr_range[i].end_addr)) {
+            zipl_secure_error("Component addresses overlap");
+       }
+    }
+}
+
+static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list,
+                                SecureIplCompEntryInfo comp_entry_info,
+                                bool is_signed)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    if (range_list->num >= MAX_COMP_ENTRIES) {
+        zipl_secure_error("Component address range update failed due to out-of-range"
+                          " index; Overlapping validation cannot be guaranteed");
+        return;
+    }
+
+    range_list->comp_addr_range[range_list->num].is_signed = is_signed;
+    range_list->comp_addr_range[range_list->num].start_addr = start_addr;
+    range_list->comp_addr_range[range_list->num].end_addr = end_addr;
+
+    range_list->num += 1;
+}
+
 static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
 {
     if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
@@ -261,6 +306,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
      * exists for the certificate).
      */
     int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
+    SecureIplCompAddrRangeList range_list = { 0 };
     int signed_count = 0;
 
     init_lists(&comp_list, &cert_list);
@@ -292,6 +338,9 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
             comp_entry_info.addr = comp_addr;
             comp_entry_info.len = (uint64_t)comp_len;
 
+            check_comp_overlap(&range_list, comp_entry_info);
+            comp_addr_range_add(&range_list, comp_entry_info, !!sig_len);
+
             /* no signature present (unsigned component) */
             if (!sig_entry_info.len) {
                 break;
pc-bios/s390-ccw/secure-ipl.h +8 -0
index cc0302f56b..29bbf65c6c 100644
@@ -24,6 +24,21 @@ typedef struct SecureIplCompEntryInfo {
     uint8_t  flags;
 } SecureIplCompEntryInfo;
 
+typedef struct SecureIplCompAddrRange {
+    bool is_signed;
+    uint64_t start_addr;
+    uint64_t end_addr;
+} SecureIplCompAddrRange;
+
+/*
+ * Custom struct for managing a list of secure IPL component address ranges.

pc-bios/s390-ccw/secure-ipl.h typedef struct SecureIplCompEntryInfo { · line 44

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.h +7 -0
+ * Tracks up to MAX_COMP_ENTRIES address ranges with an num counter.
+ */
+typedef struct SecureIplCompAddrRangeList {
+    SecureIplCompAddrRange comp_addr_range[MAX_COMP_ENTRIES];
+    int num;
+} SecureIplCompAddrRangeList;
+
 static inline void zipl_secure_error(const char *message)
 {
     switch (boot_mode) {

I wonder if these checks are necessary in the BIOS, since it looks like the kernel will handle it in arch/s390/boot/ipl_report.c and physmem_info.c? I guess confirmation is needed to check if component address are checked by the kernel.

If it's still needed, perhaps model the code after how the intersect function works to simplify things a bit.

Otherwise, I think it's safe to drop this patch and let the kernel manage checking the memory overlaps.

Signature · 2 lines
Regards,
  Collin
#48 lore raw

Re: [PATCH v11 22/32] pc-bios/s390-ccw: Add signed component address overlap checks

Quoted 116 lines · Collin Walling
Quoted 99 lines · Zhuoying Cai

Add address range tracking and overlap checks to ensure that no component overlaps with a signed component during secure IPL.

---
 pc-bios/s390-ccw/secure-ipl.c | 49 +++++++++++++++++++++++++++++++++++
 pc-bios/s390-ccw/secure-ipl.h | 15 +++++++++++
 2 files changed, 64 insertions(+)
pc-bios/s390-ccw/secure-ipl.c +49 -0
index 6e943446a7..fdac74aa97 100644
@@ -220,6 +220,51 @@ static void init_lists(IplDeviceComponentList *comp_list,
     cert_list->ipl_info_header.len = sizeof(IplInfoBlockHeader);
 }
 
+static void check_comp_overlap(SecureIplCompAddrRangeList *range_list,
+                               SecureIplCompEntryInfo comp_entry_info)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    /*
+     * Check component's address range does not overlap with any
+     * signed component's address range.
+     */
+    for (int i = 0; i < range_list->num; i++) {
+        if (range_list->comp_addr_range[i].is_signed &&
+            (range_list->comp_addr_range[i].start_addr < end_addr &&
+            start_addr < range_list->comp_addr_range[i].end_addr)) {
+            zipl_secure_error("Component addresses overlap");
+       }
+    }
+}
+
+static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list,
+                                SecureIplCompEntryInfo comp_entry_info,
+                                bool is_signed)
+{
+    uint64_t start_addr;
+    uint64_t end_addr;
+
+    start_addr = comp_entry_info.addr;
+    end_addr = comp_entry_info.addr + comp_entry_info.len;
+
+    if (range_list->num >= MAX_COMP_ENTRIES) {
+        zipl_secure_error("Component address range update failed due to out-of-range"
+                          " index; Overlapping validation cannot be guaranteed");
+        return;
+    }
+
+    range_list->comp_addr_range[range_list->num].is_signed = is_signed;
+    range_list->comp_addr_range[range_list->num].start_addr = start_addr;
+    range_list->comp_addr_range[range_list->num].end_addr = end_addr;
+
+    range_list->num += 1;
+}
+
 static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
 {
     if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
@@ -261,6 +306,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
      * exists for the certificate).
      */
     int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
+    SecureIplCompAddrRangeList range_list = { 0 };
     int signed_count = 0;
 
     init_lists(&comp_list, &cert_list);
@@ -292,6 +338,9 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
             comp_entry_info.addr = comp_addr;
             comp_entry_info.len = (uint64_t)comp_len;
 
+            check_comp_overlap(&range_list, comp_entry_info);
+            comp_addr_range_add(&range_list, comp_entry_info, !!sig_len);
+
             /* no signature present (unsigned component) */
             if (!sig_entry_info.len) {
                 break;
pc-bios/s390-ccw/secure-ipl.h +8 -0
index cc0302f56b..29bbf65c6c 100644
@@ -24,6 +24,21 @@ typedef struct SecureIplCompEntryInfo {
     uint8_t  flags;
 } SecureIplCompEntryInfo;
 
+typedef struct SecureIplCompAddrRange {
+    bool is_signed;
+    uint64_t start_addr;
+    uint64_t end_addr;
+} SecureIplCompAddrRange;
+
+/*
+ * Custom struct for managing a list of secure IPL component address ranges.

pc-bios/s390-ccw/secure-ipl.h typedef struct SecureIplCompEntryInfo { · line 44

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.h +7 -0
+ * Tracks up to MAX_COMP_ENTRIES address ranges with an num counter.
+ */
+typedef struct SecureIplCompAddrRangeList {
+    SecureIplCompAddrRange comp_addr_range[MAX_COMP_ENTRIES];
+    int num;
+} SecureIplCompAddrRangeList;
+
 static inline void zipl_secure_error(const char *message)
 {
     switch (boot_mode) {

I wonder if these checks are necessary in the BIOS, since it looks like the kernel will handle it in arch/s390/boot/ipl_report.c and physmem_info.c? I guess confirmation is needed to check if component address are checked by the kernel.

Quoted 6 lines

If it's still needed, perhaps model the code after how the intersect function works to simplify things a bit.

Otherwise, I think it's safe to drop this patch and let the kernel manage checking the memory overlaps.

The checks are still necessary in the BIOS because component addresses are preserved but not validated for overlaps by the kernel. I’ll model the code after the kernel’s intersect function. Thanks for the suggestion!

#49 lore raw

Re: [PATCH v11 22/32] pc-bios/s390-ccw: Add signed component address overlap checks

In reply to Zhuoying Cai

On 5/5/26 16:18, Zhuoying Cai wrote:

[...]

pc-bios/s390-ccw/secure-ipl.h typedef struct SecureIplCompEntryInfo { · line 38

Quoted 12 lines
pc-bios/s390-ccw/secure-ipl.h +12 -0
+typedef struct SecureIplCompAddrRange {
+    bool is_signed;
+    uint64_t start_addr;
+    uint64_t end_addr;
+} SecureIplCompAddrRange;
+
+/*
+ * Custom struct for managing a list of secure IPL component address ranges.
+ * Tracks up to MAX_COMP_ENTRIES address ranges with an num counter.
+ */
+typedef struct SecureIplCompAddrRangeList {
+    SecureIplCompAddrRange comp_addr_range[MAX_COMP_ENTRIES];

What about using a IplDeviceComponentEntry here? It has an addr (same as start_addr), length (same as end_addr = start + length), and flags (can be checked if it's signed).

In fact, couldn't the existing IplDeviceComponentEntry array inside the IplDeviceComponentList be used? Then these two data structures aren't needed.

Quoted 3 lines
pc-bios/s390-ccw/secure-ipl.h +3 -0
+    int num;
+} SecureIplCompAddrRangeList;
+
Signature · 2 lines
Regards,
  Collin
#50 lore raw

PATCH v11 23/32 s390x: Guest support for Secure-IPL Code Loading Attributes Facility (SCLAF)

In reply to Zhuoying Cai

The secure-IPL-code-loading-attributes facility (SCLAF) provides additional security during secure IPL.

Availability of SCLAF is determined by byte 136 bit 3 of the SCLP Read Info block.

This feature is available starting with the gen16 CPU model.

---
 docs/specs/s390x-secure-ipl.rst     | 18 ++++++++++++++++++
 target/s390x/cpu_features.c         |  2 ++
 target/s390x/cpu_features_def.h.inc |  1 +
 target/s390x/cpu_models.c           |  3 +++
 target/s390x/gen-features.c         |  2 ++
 target/s390x/kvm/kvm.c              |  1 +
 6 files changed, 27 insertions(+)
docs/specs/s390x-secure-ipl.rst +18 -0
index c858d5b74b..5fc15be99c 100644
@@ -118,3 +118,21 @@ The guest kernel uses the contents in the IIRB for:
 * Boot logging: reports which components were loaded and verified.
 * kexec operations: builds the next kernel’s IPL report from the existing one.
 * Keying: installs IPL certificates into the platform trusted keyring.
+
+Secure Code Loading Attributes Facility
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The Secure Code Loading Attributes Facility (SCLAF) enhances system security
+during the IPL by enforcing additional verification rules.
+
+When SCLAF is available, its behavior depends on the IPL mode. It introduces
+verification of both signed and unsigned components to help ensure that only
+authorized code is loaded during the IPL process. Any errors detected by SCLAF
+are reported in the IIRB.
+
+Unsigned components are restricted to load addresses at or above absolute
+storage address ``0x2000``.
+
+Signed components must include a Secure Code Loading Attribute Block (SCLAB),
+which is appended at the very end of the component. The SCLAB defines security
+attributes for handling the signed code.
target/s390x/cpu_features.c +2 -0
index 200bd8c15b..29ea3bfec2 100644
@@ -120,6 +120,7 @@ void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
      * - All SIE facilities because SIE is not available
      * - DIAG318
      * - Secure IPL Facility
+     * - Secure IPL Code Loading Attributes Facility
      *
      * As VMs can move in and out of protected mode the CPU model
      * doesn't protect us from that problem because it is only
@@ -152,6 +153,7 @@ void s390_fill_feat_block(const S390FeatBitmap features, S390FeatType type,
         break;
     case S390_FEAT_TYPE_SCLP_FAC_IPL:
         clear_be_bit(s390_feat_def(S390_FEAT_SIPL)->bit, data);
+        clear_be_bit(s390_feat_def(S390_FEAT_SCLAF)->bit, data);
         break;
     default:
         return;
target/s390x/cpu_features_def.h.inc +1 -0
index bcf8a666e4..f6ba9e87e1 100644
@@ -142,6 +142,7 @@ DEF_FEAT(CERT_STORE, "cstore", SCLP_FAC134, 5, "Certificate Store functions")
 
 /* Features exposed via SCLP SCCB Facilities byte 136 - 137 (bit numbers relative to byte-136) */
 DEF_FEAT(SIPL, "sipl", SCLP_FAC_IPL, 1, "Secure-IPL facility")
+DEF_FEAT(SCLAF, "sclaf", SCLP_FAC_IPL, 3, "Secure-IPL-code-loading-attributes facility")
 
 /* Features exposed via SCLP CPU info. */
 DEF_FEAT(SIE_F2, "sief2", SCLP_CPU, 4, "SIE: interception format 2 (Virtual SIE)")
target/s390x/cpu_models.c +3 -0
index a52e34aa95..7de727a256 100644
@@ -264,6 +264,7 @@ bool s390_has_feat(S390Feat feat)
         case S390_FEAT_SIE_PFMFI:
         case S390_FEAT_SIE_IBS:
         case S390_FEAT_SIPL:
+        case S390_FEAT_SCLAF:
         case S390_FEAT_CONFIGURATION_TOPOLOGY:
             return false;
             break;
@@ -509,6 +510,8 @@ static void check_consistency(const S390CPUModel *model)
         { S390_FEAT_DIAG_318, S390_FEAT_EXTENDED_LENGTH_SCCB },
         { S390_FEAT_CERT_STORE, S390_FEAT_EXTENDED_LENGTH_SCCB },
         { S390_FEAT_SIPL, S390_FEAT_EXTENDED_LENGTH_SCCB },
+        { S390_FEAT_SCLAF, S390_FEAT_EXTENDED_LENGTH_SCCB },
+        { S390_FEAT_SCLAF, S390_FEAT_SIPL },
         { S390_FEAT_NNPA, S390_FEAT_VECTOR },
         { S390_FEAT_RDP, S390_FEAT_LOCAL_TLB_CLEARING },
         { S390_FEAT_UV_FEAT_AP, S390_FEAT_AP },
target/s390x/gen-features.c +2 -0
index bd2060ab93..c3e0c6ceff 100644
@@ -722,6 +722,7 @@ static uint16_t full_GEN16_GA1[] = {
     S390_FEAT_UV_FEAT_AP_INTR,
     S390_FEAT_CERT_STORE,
     S390_FEAT_SIPL,
+    S390_FEAT_SCLAF,
 };
 
 static uint16_t full_GEN17_GA1[] = {
@@ -924,6 +925,7 @@ static uint16_t qemu_MAX[] = {
     S390_FEAT_EXTENDED_LENGTH_SCCB,
     S390_FEAT_CERT_STORE,
     S390_FEAT_SIPL,
+    S390_FEAT_SCLAF,
 };
 
 /****** END FEATURE DEFS ******/
target/s390x/kvm/kvm.c +1 -0
index e76ff37cc3..5417eb9b09 100644
@@ -2494,6 +2494,7 @@ bool kvm_s390_get_host_cpu_model(S390CPUModel *model, Error **errp)
 
     /* Some Secure IPL facilities are emulated by QEMU */
     set_bit(S390_FEAT_SIPL, model->features);
+    set_bit(S390_FEAT_SCLAF, model->features);
 
     /* Test for Ultravisor features that influence secure guest behavior */
     query_uv_feat_guest(model->features);
Signature · 1 line
2.54.0
#51 lore raw

PATCH v11 24/32 pc-bios/s390-ccw: Add additional security checks for secure boot

In reply to Zhuoying Cai

Add additional checks to ensure that components do not overlap with signed components when loaded into memory.

Add additional checks to ensure the load addresses of unsigned components are greater than or equal to 0x2000.

When the secure IPL code loading attributes facility (SCLAF) is installed, all signed components must contain a secure code loading attributes block (SCLAB).

The SCLAB provides further validation of information on where to load the signed binary code from the load device, and where to start the execution of the loaded OS code.

When SCLAF is installed, its content must be evaluated during secure IPL.

Add IPL Information Error Indicators (IIEI) and Component Error Indicators (CEI) for IPL Information Report Block (IIRB).

When SCLAF is installed, additional secure boot checks are performed during zipl and store results of verification into IIRB.

---
 include/hw/s390x/ipl/qipl.h   |  29 ++++-
 pc-bios/s390-ccw/sclp.h       |   1 +
 pc-bios/s390-ccw/secure-ipl.c | 210 +++++++++++++++++++++++++++++++++-
 pc-bios/s390-ccw/secure-ipl.h |  62 ++++++++++
 4 files changed, 296 insertions(+), 6 deletions(-)
include/hw/s390x/ipl/qipl.h +27 -2
index a2180719b1..2a3ae6b9f5 100644
@@ -167,10 +167,20 @@ struct IplInfoReportBlockHeader {
 };
 typedef struct IplInfoReportBlockHeader IplInfoReportBlockHeader;
 
+/* IPL Info Error Indicators */
+#define S390_IIEI_NO_SIGNED_COMP      0x8000 /* bit 0 */
+#define S390_IIEI_NO_SCLAB            0x4000 /* bit 1 */
+#define S390_IIEI_NO_GLOBAL_SCLAB     0x2000 /* bit 2 */
+#define S390_IIEI_MORE_GLOBAL_SCLAB   0x1000 /* bit 3 */
+#define S390_IIEI_FOUND_UNSIGNED_COMP 0x800 /* bit 4 */
+#define S390_IIEI_MORE_SIGNED_COMP    0x400 /* bit 5 */
+
 struct IplInfoBlockHeader {
     uint32_t len;
     uint8_t  type;
-    uint8_t  reserved1[11];
+    uint8_t  reserved1[3];
+    uint16_t iiei;
+    uint8_t  reserved2[6];
 };
 typedef struct IplInfoBlockHeader IplInfoBlockHeader;
 
@@ -194,13 +204,28 @@ typedef struct IplSignatureCertificateList IplSignatureCertificateList;
 #define S390_IPL_DEV_COMP_FLAG_SC  0x80
 #define S390_IPL_DEV_COMP_FLAG_CSV 0x40
 
+/* IPL Device Component Error Indicators */
+#define S390_CEI_INVALID_SCLAB             0x80000000 /* bit 0 */
+#define S390_CEI_INVALID_SCLAB_LEN         0x40000000 /* bit 1 */
+#define S390_CEI_INVALID_SCLAB_FORMAT      0x20000000 /* bit 2 */
+#define S390_CEI_UNMATCHED_SCLAB_LOAD_ADDR 0x10000000 /* bit 3 */
+#define S390_CEI_UNMATCHED_SCLAB_LOAD_PSW  0x8000000  /* bit 4 */
+#define S390_CEI_INVALID_LOAD_PSW          0x4000000  /* bit 5 */
+#define S390_CEI_NUC_NOT_IN_GLOBAL_SCLAB   0x2000000  /* bit 6 */
+#define S390_CEI_SCLAB_OLA_NOT_ONE         0x1000000  /* bit 7 */
+#define S390_CEI_SC_NOT_IN_GLOBAL_SCLAB    0x800000   /* bit 8 */
+#define S390_CEI_SCLAB_LOAD_ADDR_NOT_ZERO  0x400000   /* bit 9 */
+#define S390_CEI_SCLAB_LOAD_PSW_NOT_ZERO   0x200000   /* bit 10 */
+#define S390_CEI_INVALID_UNSIGNED_ADDR     0x100000   /* bit 11 */
+
 struct IplDeviceComponentEntry {
     uint64_t addr;
     uint64_t len;
     uint8_t  flags;
     uint8_t  reserved1[5];
     uint16_t cert_index;
-    uint8_t  reserved2[8];
+    uint32_t cei;
+    uint8_t  reserved2[4];
 };
 typedef struct IplDeviceComponentEntry IplDeviceComponentEntry;
 
pc-bios/s390-ccw/sclp.h +1 -0
index a8a41cd004..cae65b29b5 100644
@@ -52,6 +52,7 @@ typedef struct SCCBHeader {
 #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
 #define SCCB_FAC134_DIAG320_BIT 0x4
 #define SCCB_FAC_IPL_SIPL_BIT   0x4000
+#define SCCB_FAC_IPL_SCLAF_BIT  0x1000
 
 typedef struct ReadInfo {
     SCCBHeader h;
pc-bios/s390-ccw/secure-ipl.c +206 -4

260 lines not on this page · raw message

pc-bios/s390-ccw/secure-ipl.h +62 -0

78 lines not on this page · raw message

Signature · 1 line
2.54.0
#52 lore raw

Re: [PATCH v11 24/32] pc-bios/s390-ccw: Add additional security checks for secure boot

Quoted 16 lines · Zhuoying Cai

Add additional checks to ensure that components do not overlap with signed components when loaded into memory.

Add additional checks to ensure the load addresses of unsigned components are greater than or equal to 0x2000.

When the secure IPL code loading attributes facility (SCLAF) is installed, all signed components must contain a secure code loading attributes block (SCLAB).

The SCLAB provides further validation of information on where to load the signed binary code from the load device, and where to start the execution of the loaded OS code.

When SCLAF is installed, its content must be evaluated during secure IPL.

Quoted 7 lines

Add IPL Information Error Indicators (IIEI) and Component Error Indicators (CEI) for IPL Information Report Block (IIRB).

When SCLAF is installed, additional secure boot checks are performed during zipl and store results of verification into IIRB.

You've done an awesome job at cleaning up the large list of parameters passed to some functions, and I think it's bringing to light some cleaner approaches to the SCLAF code.

Here's what I'm thinking:
- process each SCLAB at the same time a component is processed (already
done here)
- Use a SclaBlock global_sclab variable to hold on to the global SCLAB
(instead of using an info struct)
- Once all components are processed, then check_global_sclab (already
done here)
- While checking the global SCLAB, iterate through the component list
to tally the signed / unsigned counts (by checking the component flags) and set errors depending on the SCLAB flags.

This will get rid of the SecureIplSclabInfo struct and the signed / unsigned counter fields can be contained within the scope of the check_global_sclab function.

Quoted 146 lines
---
 include/hw/s390x/ipl/qipl.h   |  29 ++++-
 pc-bios/s390-ccw/sclp.h       |   1 +
 pc-bios/s390-ccw/secure-ipl.c | 210 +++++++++++++++++++++++++++++++++-
 pc-bios/s390-ccw/secure-ipl.h |  62 ++++++++++
 4 files changed, 296 insertions(+), 6 deletions(-)
include/hw/s390x/ipl/qipl.h +27 -2
index a2180719b1..2a3ae6b9f5 100644
@@ -167,10 +167,20 @@ struct IplInfoReportBlockHeader {
 };
 typedef struct IplInfoReportBlockHeader IplInfoReportBlockHeader;
 
+/* IPL Info Error Indicators */
+#define S390_IIEI_NO_SIGNED_COMP      0x8000 /* bit 0 */
+#define S390_IIEI_NO_SCLAB            0x4000 /* bit 1 */
+#define S390_IIEI_NO_GLOBAL_SCLAB     0x2000 /* bit 2 */
+#define S390_IIEI_MORE_GLOBAL_SCLAB   0x1000 /* bit 3 */
+#define S390_IIEI_FOUND_UNSIGNED_COMP 0x800 /* bit 4 */
+#define S390_IIEI_MORE_SIGNED_COMP    0x400 /* bit 5 */
+
 struct IplInfoBlockHeader {
     uint32_t len;
     uint8_t  type;
-    uint8_t  reserved1[11];
+    uint8_t  reserved1[3];
+    uint16_t iiei;
+    uint8_t  reserved2[6];
 };
 typedef struct IplInfoBlockHeader IplInfoBlockHeader;
 
@@ -194,13 +204,28 @@ typedef struct IplSignatureCertificateList IplSignatureCertificateList;
 #define S390_IPL_DEV_COMP_FLAG_SC  0x80
 #define S390_IPL_DEV_COMP_FLAG_CSV 0x40
 
+/* IPL Device Component Error Indicators */
+#define S390_CEI_INVALID_SCLAB             0x80000000 /* bit 0 */
+#define S390_CEI_INVALID_SCLAB_LEN         0x40000000 /* bit 1 */
+#define S390_CEI_INVALID_SCLAB_FORMAT      0x20000000 /* bit 2 */
+#define S390_CEI_UNMATCHED_SCLAB_LOAD_ADDR 0x10000000 /* bit 3 */
+#define S390_CEI_UNMATCHED_SCLAB_LOAD_PSW  0x8000000  /* bit 4 */
+#define S390_CEI_INVALID_LOAD_PSW          0x4000000  /* bit 5 */
+#define S390_CEI_NUC_NOT_IN_GLOBAL_SCLAB   0x2000000  /* bit 6 */
+#define S390_CEI_SCLAB_OLA_NOT_ONE         0x1000000  /* bit 7 */
+#define S390_CEI_SC_NOT_IN_GLOBAL_SCLAB    0x800000   /* bit 8 */
+#define S390_CEI_SCLAB_LOAD_ADDR_NOT_ZERO  0x400000   /* bit 9 */
+#define S390_CEI_SCLAB_LOAD_PSW_NOT_ZERO   0x200000   /* bit 10 */
+#define S390_CEI_INVALID_UNSIGNED_ADDR     0x100000   /* bit 11 */
+
 struct IplDeviceComponentEntry {
     uint64_t addr;
     uint64_t len;
     uint8_t  flags;
     uint8_t  reserved1[5];
     uint16_t cert_index;
-    uint8_t  reserved2[8];
+    uint32_t cei;
+    uint8_t  reserved2[4];
 };
 typedef struct IplDeviceComponentEntry IplDeviceComponentEntry;
 
pc-bios/s390-ccw/sclp.h +1 -0
index a8a41cd004..cae65b29b5 100644
@@ -52,6 +52,7 @@ typedef struct SCCBHeader {
 #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
 #define SCCB_FAC134_DIAG320_BIT 0x4
 #define SCCB_FAC_IPL_SIPL_BIT   0x4000
+#define SCCB_FAC_IPL_SCLAF_BIT  0x1000
 
 typedef struct ReadInfo {
     SCCBHeader h;
pc-bios/s390-ccw/secure-ipl.c +49 -0
index fdac74aa97..9c992149ee 100644
@@ -140,6 +140,7 @@ static void comp_list_add(IplDeviceComponentList *comp_list,
 
     comp_list->device_entries[comp_entry_idx].addr = comp_entry_info.addr;
     comp_list->device_entries[comp_entry_idx].len = comp_entry_info.len;
+    comp_list->device_entries[comp_entry_idx].cei = comp_entry_info.cei;
     comp_list->device_entries[comp_entry_idx].flags = comp_entry_info.flags;
     /* cert index field is meaningful only when S390_IPL_DEV_COMP_FLAG_SC is set */
     if (comp_entry_info.flags & S390_IPL_DEV_COMP_FLAG_SC) {
@@ -207,6 +208,12 @@ bool secure_ipl_supported(void)
         return false;
     }
 
+    if (!sclp_is_fac_ipl_flag_on(SCCB_FAC_IPL_SCLAF_BIT)) {
+        puts("Secure IPL Code Loading Attributes Facility is not supported by"
+             " the hypervisor!");
+        return false;
+    }
+
     return true;
 }
 
@@ -265,6 +272,179 @@ static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list,
     range_list->num += 1;
 }
 
+static void check_sclab_opsw(SclaBlock *sclab, SecureIplSclabInfo *sclab_info,
+                             uint32_t *cei_flags)
+{
+    if (!(sclab->flags & S390_SCLAB_OPSW)) {
+        /* OPSW = 0 - Load PSW field in SCLAB must contain zeros */
+        zipl_secure_validate(sclab->load_psw == 0, cei_flags,
+                             S390_CEI_SCLAB_LOAD_PSW_NOT_ZERO,
+                             "Load PSW is not zero when Override PSW bit is zero");
+    } else {
+        /* OPSW = 1 indicating global SCLAB */
+        sclab_info->global_count += 1;
+        if (sclab_info->global_count == 1) {
+            sclab_info->global_load_psw = sclab->load_psw;
+            sclab_info->global_flags = sclab->flags;
+        }
+
+        /* override load address flag must set to one */
+        zipl_secure_validate(sclab->flags & S390_SCLAB_OLA, cei_flags,
+                             S390_CEI_SCLAB_LOAD_PSW_NOT_ZERO,
+                             "OLA flag is not set to one in the global SCLAB");
+    }
+}
+
+static void check_sclab_ola(SclaBlock *sclab, uint64_t load_addr, uint32_t *cei_flags)
+{
+    if (!(sclab->flags & S390_SCLAB_OLA)) {
+        /* OLA = 0 - Load address field in SCLAB must contain zeros */
+        zipl_secure_validate(sclab->load_addr == 0, cei_flags,
+                             S390_CEI_SCLAB_LOAD_ADDR_NOT_ZERO,
+                             "Load Address is not zero when OLA flag is zero");
+    } else {
+        /* OLA = 1 - Load address field must match storage address of the component */
+        zipl_secure_validate(sclab->load_addr == load_addr, cei_flags,
+                             S390_CEI_UNMATCHED_SCLAB_LOAD_ADDR,
+                             "Load Address does not match with component load address");
+    }
+}
+
+static bool is_psw_valid(uint64_t psw, SecureIplCompAddrRangeList *range_list)
+{
+    uint32_t addr = psw & 0x7fffffff;
+

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 326

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c +10 -0
+    /* PSW points within a signed binary code component */
+    for (int i = 0; i < range_list->num; i++) {
+        if (range_list->comp_addr_range[i].is_signed &&
+            addr >= range_list->comp_addr_range[i].start_addr &&
+            addr <= range_list->comp_addr_range[i].end_addr - 2) {
+            return true;
+       }
+    }
+    return false;
+}

This function is very similar to check_comp_overlap. I suggest making a single "check_overlap" or "intersect" function (the latter mirrors the naming scheme in the kernel) to combine their functionality and then have their callers handle the outcome.

e.g. the if function will return true if there is an overlap/intersect. For components, caller will true it as an error. For the PSW check, the caller will treat true as success.

Quoted 29 lines
pc-bios/s390-ccw/secure-ipl.c +29 -0
+
+static void check_load_psw(SecureIplCompAddrRangeList *range_list,
+                           uint64_t sclab_load_psw,
+                           SecureIplCompEntryInfo *comp_entry_info)
+{
+    uint64_t load_psw;
+
+    load_psw = comp_entry_info->addr;
+    zipl_secure_validate(is_psw_valid(sclab_load_psw, range_list) &&
+                         is_psw_valid(load_psw, range_list),
+                         &comp_entry_info->cei, S390_CEI_INVALID_LOAD_PSW, "Invalid PSW");
+
+    /* compare load PSW with the PSW specified in component */
+    zipl_secure_validate(sclab_load_psw == load_psw, &comp_entry_info->cei,
+                         S390_CEI_UNMATCHED_SCLAB_LOAD_PSW,
+                         "Load PSW does not match with PSW in component");
+}
+
+static void check_no_unsigned_comp(SecureIplSclabInfo sclab_info,
+                                   IplDeviceComponentList *comp_list)
+{
+    bool is_nuc_set;
+
+    is_nuc_set = sclab_info.global_flags & S390_SCLAB_NUC;
+    if (is_nuc_set && sclab_info.unsigned_count > 0) {
+        comp_list->ipl_info_header.iiei |= S390_IIEI_FOUND_UNSIGNED_COMP;
+        zipl_secure_error("Unsigned components are not allowed");
+    }
+}

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 365

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c +10 -0
+
+static void check_single_comp(SecureIplSclabInfo sclab_info,
+                              IplDeviceComponentList *comp_list)
+{
+    bool is_sc_set;
+
+    is_sc_set = sclab_info.global_flags & S390_SCLAB_SC;
+    if (is_sc_set &&
+        sclab_info.signed_count != 1 &&
+        sclab_info.unsigned_count >= 0) {

Does the unsigned count matter here?

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 369

Quoted 4 lines
pc-bios/s390-ccw/secure-ipl.c +4 -0
+        comp_list->ipl_info_header.iiei |= S390_IIEI_MORE_SIGNED_COMP;
+        zipl_secure_error("Only one signed component is allowed");
+    }
+}

For both functions check_no_unsigned_comp and check_single_comp, could a zipl_secure_validate be used instead?

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 372

Quoted 3 lines
pc-bios/s390-ccw/secure-ipl.c +3 -0
+
+void check_global_sclab(SecureIplSclabInfo sclab_info,
+                        IplDeviceComponentList *comp_list)

Pass this a SclaBlock global_sclab (which should've been assigned by a subsequent call to check_sclab -- see below), and the IplDeviceComponentList *comp_list. Iterate through the list and check each comp.flags for signed and unsigned components, and check PSW validity.

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 376

Quoted 4 lines
pc-bios/s390-ccw/secure-ipl.c +4 -0
+{
+    if (sclab_info.count == 0) {
+        return;
+    }

Is this check needed here? zipl_secure_validate(sclab_info.count > 0, ...) is called before this function anyway.

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 378

Quoted 2 lines
pc-bios/s390-ccw/secure-ipl.c +2 -0
+
+    if (sclab_info.global_count == 0) {

Would be: if (!global_sclab)

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 384

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c +6 -0
+        comp_list->ipl_info_header.iiei |= S390_IIEI_NO_GLOBAL_SCLAB;
+        zipl_secure_error("Global SCLAB does not exists");
+        return;
+    }
+
+    if (sclab_info.global_count > 1) {

This check should happen earlier in check_sclab() (see below).

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 395

Quoted 11 lines
pc-bios/s390-ccw/secure-ipl.c +11 -0
+        comp_list->ipl_info_header.iiei |= S390_IIEI_MORE_GLOBAL_SCLAB;
+        zipl_secure_error("More than one global SCLAB");
+        return;
+    }
+
+    if (sclab_info.global_flags) {
+        /* Unsigned components are not allowed if NUC flag is set in the global SCLAB */
+        check_no_unsigned_comp(sclab_info, comp_list);
+
+        /* Only one signed component is allowed is SC flag is set in the global SCLAB */
+        check_single_comp(sclab_info, comp_list);

Move both function bodies to here, they're small enough and it'll be easier to read (the comments are helpful)

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 401

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c +6 -0
+    }
+}
+
+static void check_sclab(SecureIplCompEntryInfo *comp_entry_info,
+                        SecureIplSclabInfo *sclab_info)
+{

Pass this a SclaBlock global_sclab. When the OPSW is set, check if !global_sclab, set global_sclab = sclab; else, set iiei.

The global_sclab is later passed to check_global_sclab().

You might need to pass this function the comp entry (to locate sclab and set cei) and the header (to set iiei)... this assumes SecureIplCompEntryInfo goes away as suggested in a previous patch.

Quoted 25 lines
pc-bios/s390-ccw/secure-ipl.c +25 -0
+    SclabOriginLocator *sclab_locator;
+    SclaBlock *sclab;
+
+    /* sclab locator is located at the last 8 bytes of the signed comp */
+    sclab_locator = (SclabOriginLocator *)(comp_entry_info->addr +
+                                           comp_entry_info->len - 8);
+
+    /* return early if sclab does not exist */
+    zipl_secure_validate(magic_match(sclab_locator->magic, ZIPL_MAGIC),
+                         &comp_entry_info->cei, S390_CEI_INVALID_SCLAB,
+                         "Magic does not match. SCLAB does not exist");
+
+    if (comp_entry_info->cei & S390_CEI_INVALID_SCLAB) {
+        return;
+    }
+
+    zipl_secure_validate(sclab_locator->len >= S390_SCLAB_MIN_LEN, &comp_entry_info->cei,
+                         S390_CEI_INVALID_SCLAB_LEN | S390_CEI_INVALID_SCLAB,
+                         "Invalid SCLAB length");
+
+    /* return early if sclab is invalid */
+    if (comp_entry_info->cei & S390_CEI_INVALID_SCLAB) {
+        return;
+    }
+

pc-bios/s390-ccw/secure-ipl.c static void comp_addr_range_add(SecureIplCompAddrRangeList *range_list, · line 436

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c +10 -0
+    sclab_info->count += 1;
+    sclab = (SclaBlock *)(comp_entry_info->addr + comp_entry_info->len -
+                          sclab_locator->len);
+
+    zipl_secure_validate(sclab->format == 0, &comp_entry_info->cei,
+                         S390_CEI_INVALID_SCLAB_FORMAT,
+                         "Format-0 SCLAB is not being used");
+
+    check_sclab_opsw(sclab, sclab_info, &comp_entry_info->cei);
+    check_sclab_ola(sclab, comp_entry_info->addr, &comp_entry_info->cei);

Both check_sclab_opsw() and check_sclab_ola() function bodies can just be put in here. They're small enough and visually similar (check flag, then zipl_secure_validate()). Would be more readable to see all sclab checking code in one view.

Quoted 24 lines
pc-bios/s390-ccw/secure-ipl.c +12 -1
+
+    zipl_secure_validate(~sclab->flags & S390_SCLAB_NUC || sclab->flags & S390_SCLAB_OPSW,
+                         &comp_entry_info->cei, S390_CEI_NUC_NOT_IN_GLOBAL_SCLAB,
+                         "NUC bit is set, but not in the global SCLAB");
+
+    zipl_secure_validate(~sclab->flags & S390_SCLAB_SC || sclab->flags & S390_SCLAB_OPSW,
+                         &comp_entry_info->cei, S390_CEI_SC_NOT_IN_GLOBAL_SCLAB,
+                         "SC bit is set, but not in the global SCLAB");
+
+}
+
 static int zipl_load_signature(ComponentEntry *entry, uint64_t sig)
 {
     if (entry->compdat.sig_info.format != DER_SIGNATURE_FORMAT) {
@@ -307,7 +487,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
      */
     int cert_list_table[MAX_CERTIFICATES] = { [0 ... MAX_CERTIFICATES - 1] = -1 };
     SecureIplCompAddrRangeList range_list = { 0 };
-    int signed_count = 0;
+    SecureIplSclabInfo sclab_info = { 0 };
 
     init_lists(&comp_list, &cert_list);
     cert_buf = malloc(get_total_certs_length());

pc-bios/s390-ccw/secure-ipl.c int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec) · line 528

Quoted 6 lines
pc-bios/s390-ccw/secure-ipl.c +3 -0
@@ -343,6 +523,13 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
 
             /* no signature present (unsigned component) */
             if (!sig_entry_info.len) {
+                zipl_secure_validate(comp_entry_info.addr >= S390_UNSIGNED_MIN_ADDR,
+                                     &comp_entry_info.cei, S390_CEI_INVALID_UNSIGNED_ADDR,
+                                     "Load address is less than 0x2000");

"Load address for unsigned component is less than 0x2000"

pc-bios/s390-ccw/secure-ipl.c int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec) · line 530

Quoted 2 lines
pc-bios/s390-ccw/secure-ipl.c +2 -0
+
+                comp_list_add(&comp_list, comp_entry_info);

Thinking about it... back in patch 21, shouldn't unsigned components be added to the list?

Quoted 26 lines
pc-bios/s390-ccw/secure-ipl.c +4 -1
+
+                sclab_info.unsigned_count += 1;
                 break;
             }
 
@@ -352,6 +539,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
              */
             comp_entry_info.flags = S390_IPL_DEV_COMP_FLAG_SC;
 
+            check_sclab(&comp_entry_info, &sclab_info);
             verified = verify_signature(comp_entry_info, sig_entry_info,
                                         &cert_len, &cert_table_idx);
 
@@ -378,7 +566,7 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
 
             comp_list_add(&comp_list, comp_entry_info);
 
-            signed_count += 1;
+            sclab_info.signed_count += 1;
             /* After a signature is used another new one can be accepted */
             sig_entry_info.len = 0;
             break;
@@ -395,10 +583,24 @@ int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec)
         }
     }
 

pc-bios/s390-ccw/secure-ipl.c int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec) · line 593

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.c +7 -2
-    if (signed_count == 0) {
-        zipl_secure_error("Secure boot is on, but components are not signed");
+    /* validate load PSW with PSW specified in the final entry */
+    if (sclab_info.global_load_psw) {
+        comp_entry_info = (SecureIplCompEntryInfo){ 0 };
+        comp_entry_info.addr = entry->compdat.load_psw;
+
+        check_load_psw(&range_list, sclab_info.global_load_psw, &comp_entry_info);
+        comp_list_add(&comp_list, comp_entry_info);
     }

This check could be done inside check_global_sclab() with the changes mentioned above. While iterating through the comp_list checking for flags, you can also check PSW validity.

pc-bios/s390-ccw/secure-ipl.c int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec) · line 600

Quoted 7 lines
pc-bios/s390-ccw/secure-ipl.c +6 -0
+    zipl_secure_validate(sclab_info.signed_count > 0,
+                         &comp_list.ipl_info_header.iiei, S390_IIEI_NO_SIGNED_COMP,
+                         "Secure boot is on, but components are not signed");
+
+    zipl_secure_validate(sclab_info.count > 0, &comp_list.ipl_info_header.iiei,
+                         S390_IIEI_NO_SCLAB, "No recognizable SCLAB");

Both of these iiei flags could be set near the start of zipl_run_secure() (which is technically true since no SCLABs or signed comps have been found at that point in time). Then, when the first valid SCLAB or signed comp is found, clear the respective flag.

At the end of this function, check if those flags are still set and call zipl_secure_error().

That will help justify getting rid of the counter fields.

Quoted 40 lines
pc-bios/s390-ccw/secure-ipl.c +3 -0
+
+    check_global_sclab(sclab_info, &comp_list);
+
     update_iirb(&comp_list, &cert_list);
 
     *entry_ptr = entry;
pc-bios/s390-ccw/secure-ipl.h +26 -0
index 29bbf65c6c..950cd45b3c 100644
@@ -16,10 +16,48 @@
 VCStorageSizeBlock *zipl_secure_get_vcssb(void);
 int zipl_run_secure(ComponentEntry **entry_ptr, uint8_t *tmp_sec);
 
+#define S390_SCLAB_OPSW    0x8000   /* override PSW flag */
+#define S390_SCLAB_OLA     0x4000   /* override load address flag */
+#define S390_SCLAB_NUC     0x2000   /* no unsigned components flag */
+#define S390_SCLAB_SC      0x1000   /* single component flag */
+
+#define S390_SCLAB_MIN_LEN      32
+#define S390_UNSIGNED_MIN_ADDR  0x2000
+
+/* Secure Code Loading Attributes Block */
+struct SclaBlock {
+    uint8_t  format;
+    uint8_t  reserved1;
+    uint16_t flags;
+    uint8_t  reserved2[4];
+    uint64_t load_psw;
+    uint64_t load_addr;
+    uint64_t reserved3[];
+} __attribute__ ((packed));
+typedef struct SclaBlock SclaBlock;
+
+struct SclabOriginLocator {
+    uint8_t reserved[2];
+    uint16_t len;
+    uint8_t magic[4];
+} __attribute__ ((packed));
+typedef struct SclabOriginLocator SclabOriginLocator;

pc-bios/s390-ccw/secure-ipl.h line 54

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.h +10 -0
+
+/* Custom struct used to consolidate SCLAB overhead */
+typedef struct SecureIplSclabInfo {
+    int count;
+    int global_count;
+    int signed_count;
+    int unsigned_count;
+    uint64_t global_load_psw;
+    uint16_t global_flags;
+} SecureIplSclabInfo;

I think with the suggestions above, this struct should no longer be needed. The global fields can be handled by tracking a special SclaBlock global_sclab. The signed/unsigned counts can be tallied by iterating through the comp list. Global count can be checked by global_sclab != NULL.

Count might be able to go away too (see above).

Quoted 27 lines
pc-bios/s390-ccw/secure-ipl.h +16 -0
+
 /* Custom struct for secure IPL component entry information */
 typedef struct SecureIplCompEntryInfo {
     uint64_t addr;
     uint64_t len;
+    uint32_t cei;
     uint16_t cert_index;
     uint8_t  flags;
 } SecureIplCompEntryInfo;
@@ -50,6 +88,30 @@ static inline void zipl_secure_error(const char *message)
     }
 }
 
+static inline void zipl_secure_validate_u16(bool condition, uint16_t *flags,
+                                            uint16_t flag, const char *message)
+{
+    if (!condition) {
+        *flags |= flag;
+        zipl_secure_error(message);
+    }
+}
+
+static inline void zipl_secure_validate_u32(bool condition, uint32_t *flags,
+                                            uint32_t flag, const char *message)
+{
+    if (!condition) {
+        *flags |= flag;

pc-bios/s390-ccw/secure-ipl.h static inline void zipl_secure_error(const char *message) · line 114

Quoted 10 lines
pc-bios/s390-ccw/secure-ipl.h +10 -0
+        zipl_secure_error(message);
+    }
+}
+
+#define zipl_secure_validate(condition, flags, flag, message)   \
+    _Generic((flags),                                           \
+        uint16_t * : zipl_secure_validate_u16,                  \
+        uint32_t * : zipl_secure_validate_u32                   \
+    )(condition, flags, flag, message)
+

This is MUCH better! :)

pc-bios/s390-ccw/secure-ipl.h static inline void zipl_secure_error(const char *message) · line 117

Quoted 3 lines
pc-bios/s390-ccw/secure-ipl.h +0 -0
 static inline uint64_t _diag320(void *data, unsigned long subcode)
 {
     register unsigned long addr asm("0") = (unsigned long)data;

With the suggestions above, most (if not all) SCLAF-related code should be contained to the check_sclab and check_global_sclab functions and less overhead managed in zipl_secure_run, which will make this a LOT easier to visually parse.

Hopefully I'm not missing a major design flaw in this thinking. Please let me know if the suggestions are not feasible.

Signature · 2 lines
Regards,
  Collin
#53 lore raw

PATCH v11 25/32 Add secure-boot to s390-ccw-virtio machine type option

In reply to Zhuoying Cai

Add secure-boot as a parameter of s390-ccw-virtio machine type option.

The secure-boot=on|off parameter is implemented to enable secure IPL.

By default, secure-boot is set to false if not specified in the command line.

---
 docs/system/s390x/secure-ipl.rst   | 22 +++++++++++++++++-----
 hw/s390x/s390-virtio-ccw.c         | 22 ++++++++++++++++++++++
 include/hw/s390x/s390-virtio-ccw.h |  1 +
 qemu-options.hx                    |  6 +++++-
 4 files changed, 45 insertions(+), 6 deletions(-)
docs/system/s390x/secure-ipl.rst +17 -5
index cf6ccf5d57..9e3955f8fc 100644
@@ -19,20 +19,32 @@ Note: certificate files must have a .pem extension.
 
     qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
 
+Enabling Secure IPL
+^^^^^^^^^^^^^^^^^^^
+
+Secure IPL is enabled by explicitly setting ``secure-boot=on``; if not
+specified, secure boot is considered off.
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on|off
+
 
 IPL Modes
 ---------
 
 Multiple IPL modes are available to differentiate between the various IPL
-configurations. These modes are mutually exclusive and enabled based on the
-``boot-certs`` option on the QEMU command line.
+configurations. These modes are mutually exclusive and enabled based on specific
+combinations of the ``secure-boot`` and ``boot-certs`` options on the QEMU
+command line.
 
 Normal Mode
 ^^^^^^^^^^^
 
-The absence of certificates will attempt to IPL a guest without secure IPL
-operations. No checks are performed, and no warnings/errors are reported.
-This is the default mode.
+The absence of both certificates and the ``secure-boot`` option will attempt to
+IPL a guest without secure IPL operations. No checks are performed, and no
+warnings/errors are reported.  This is the default mode, and can be explicitly
+enabled with ``secure-boot=off``.
 
 Configuration:
 
hw/s390x/s390-virtio-ccw.c +22 -0
index 39adb69cfd..4f429a72ac 100644
@@ -813,6 +813,21 @@ static void machine_set_boot_certs(Object *obj, Visitor *v, const char *name,
     ms->boot_certs = cert_list;
 }
 
+static inline bool machine_get_secure_boot(Object *obj, Error **errp)
+{
+    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+
+    return ms->secure_boot;
+}
+
+static inline void machine_set_secure_boot(Object *obj, bool value,
+                                            Error **errp)
+{
+    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+
+    ms->secure_boot = value;
+}
+
  /*
   * S390x-specific global compatibility properties.
   *
@@ -886,6 +901,13 @@ static void ccw_machine_class_init(ObjectClass *oc, const void *data)
                               machine_get_boot_certs, machine_set_boot_certs, NULL, NULL);
     object_class_property_set_description(oc, "boot-certs",
             "provide paths to a directory and/or a certificate file for secure boot");
+
+    object_class_property_add_bool(oc, "secure-boot",
+                                   machine_get_secure_boot,
+                                   machine_set_secure_boot);
+    object_class_property_set_description(oc, "secure-boot",
+            "enable/disable secure boot");
+
 }
 
 static inline void s390_machine_initfn(Object *obj)
include/hw/s390x/s390-virtio-ccw.h +1 -0
index 5ad1ea2f24..93a4c0ccad 100644
@@ -29,6 +29,7 @@ struct S390CcwMachineState {
     bool aes_key_wrap;
     bool dea_key_wrap;
     bool pv;
+    bool secure_boot;
     uint8_t loadparm[8];
     uint64_t memory_limit;
     uint64_t max_pagesize;
qemu-options.hx +5 -1
index 7f97a0d07e..342c913c30 100644
@@ -46,7 +46,8 @@ DEF("machine", HAS_ARG, QEMU_OPTION_machine, \
     "                cxl-fmw.0.targets.0=firsttarget,cxl-fmw.0.targets.1=secondtarget,cxl-fmw.0.size=size[,cxl-fmw.0.interleave-granularity=granularity]\n"
     "                sgx-epc.0.memdev=memid,sgx-epc.0.node=numaid\n"
     "                smp-cache.0.cache=cachename,smp-cache.0.topology=topologylevel\n"
-    "                boot-certs.0.path=/path/directory,boot-certs.1.path=/path/file provides paths to a directory and/or a certificate file\n",
+    "                boot-certs.0.path=/path/directory,boot-certs.1.path=/path/file provides paths to a directory and/or a certificate file\n"
+    "                secure-boot=on|off enable/disable secure boot (default=off) \n",
     QEMU_ARCH_ALL)
 SRST
 ``-machine [type=]name[,prop=value[,...]]``
@@ -213,6 +214,9 @@ SRST
 
     ``boot-certs.0.path=/path/directory,boot-certs.1.path=/path/file``
         Provide paths to a directory and/or a certificate file on the host [s390x only].
+
+    ``secure-boot=on|off``
+        Enables or disables secure boot on s390-ccw guest. The default is off.
 ERST
 
 DEF("M", HAS_ARG, QEMU_OPTION_M,
Signature · 1 line
2.54.0
#55 lore raw

PATCH v11 26/32 hw/s390x/ipl: Set IPIB flags for secure IPL

In reply to Zhuoying Cai

If -M secure-boot=on is specified on the command line option, indicating true secure IPL enabled, set Secure-IPL bit and IPL-Information-Report bit on in IPIB Flags field, and trigger true secure IPL in the S390 BIOS.

Any error that occurs during true secure IPL will cause the IPL to terminate.

---
 hw/s390x/ipl.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)
hw/s390x/ipl.c +18 -1
index f4311f6d62..67e8231c76 100644
@@ -468,6 +468,11 @@ static bool s390_has_certificate(void)
     return ipl->cert_store.count > 0;
 }
 
+static bool s390_secure_boot_enabled(void)
+{
+    return S390_CCW_MACHINE(qdev_get_machine())->secure_boot;
+}
+
 static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
 {
     CcwDevice *ccw_dev = NULL;
@@ -524,6 +529,18 @@ static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
         s390_ipl_convert_loadparm((char *)lp, iplb->loadparm);
         iplb->flags |= DIAG308_FLAGS_LP_VALID;
 
+        /*
+         * If secure-boot is enabled, then toggle the secure IPL flags to
+         * trigger secure boot in the s390 BIOS.
+         *
+         * Boot process will terminate if any error occurs during secure boot.
+         *
+         * If SIPL is on, IPLIR must also be on.
+         */
+        if (s390_secure_boot_enabled()) {
+            iplb->hdr_flags |= (DIAG308_IPIB_FLAGS_SIPL | DIAG308_IPIB_FLAGS_IPLIR);
+            iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
+        }
         /*
          * Secure boot in audit mode will perform
          * if certificate(s) exist in the key store.
@@ -533,7 +550,7 @@ static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
          *
          * Results of secure boot will be stored in IIRB.
          */
-        if (s390_has_certificate()) {
+        else if (s390_has_certificate()) {
             iplb->hdr_flags |= DIAG308_IPIB_FLAGS_IPLIR;
             iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
         }
Signature · 1 line
2.54.0
#56 lore raw

PATCH v11 27/32 pc-bios/s390-ccw: Handle true secure IPL mode

In reply to Zhuoying Cai

When secure boot is enabled (-secure-boot on) and certificate(s) are provided, the boot operates in True Secure IPL mode.

Any verification error during True Secure IPL mode will cause the entire boot process to terminate.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities. If secure boot is enabled but no certificate is provided, the boot process will also terminate, as this is not a valid secure boot configuration.

Note: True Secure IPL mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
 docs/system/s390x/secure-ipl.rst | 13 +++++++++++++
 pc-bios/s390-ccw/bootmap.c       |  8 ++++++++
 pc-bios/s390-ccw/main.c          |  3 ++-
 pc-bios/s390-ccw/s390-ccw.h      |  1 +
 pc-bios/s390-ccw/secure-ipl.h    |  3 +++
 5 files changed, 27 insertions(+), 1 deletion(-)
docs/system/s390x/secure-ipl.rst +13 -0
index 9e3955f8fc..c8fb887ac0 100644
@@ -66,3 +66,16 @@ Configuration:
 .. code-block:: shell
 
     qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
+
+Secure Mode
+^^^^^^^^^^^
+
+When the ``secure-boot=on`` option is set and certificates are provided,
+a secure boot is performed with error reporting enabled. The boot process aborts
+if any error occurs.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/bootmap.c +8 -0
index a300fba8cd..8f54c15144 100644
@@ -738,6 +738,7 @@ static int zipl_run(ScsiBlockPtr *pte)
     case ZIPL_BOOT_MODE_NORMAL:
         rc = zipl_run_normal(&entry, tmp_sec);
         break;
+    case ZIPL_BOOT_MODE_SECURE:
     case ZIPL_BOOT_MODE_SECURE_AUDIT:
         rc = zipl_run_secure(&entry, tmp_sec);
         break;
@@ -1115,9 +1116,16 @@ ZiplBootMode get_boot_mode(uint8_t hdr_flags)
 {
     bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
     bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+    VCStorageSizeBlock *vcssb;
 
     if (!sipl_set && iplir_set) {
         return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    } else if (sipl_set && iplir_set) {
+        vcssb = zipl_secure_get_vcssb();
+        if (vcssb == NULL || vcssb->length == VCSSB_NO_VC) {
+            panic("Need at least one certificate for secure boot!");
+        }
+        return ZIPL_BOOT_MODE_SECURE;
     }
 
     return ZIPL_BOOT_MODE_NORMAL;
pc-bios/s390-ccw/main.c +2 -1
index 0bcd32b059..e34179a05f 100644
@@ -396,9 +396,10 @@ void main(void)
 
     boot_mode = get_boot_mode(iplb->hdr_flags);
     switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE:
     case ZIPL_BOOT_MODE_SECURE_AUDIT:
         if (!secure_ipl_supported()) {
-            panic("Unable to boot in audit mode");
+            panic("Unable to boot in secure/audit mode");
         }
     default:
         break;
pc-bios/s390-ccw/s390-ccw.h +1 -0
index b66a9b50bf..7a7bf7720b 100644
@@ -90,6 +90,7 @@ void zipl_load(void);
 typedef enum ZiplBootMode {
     ZIPL_BOOT_MODE_NORMAL = 0,
     ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
+    ZIPL_BOOT_MODE_SECURE = 2,
 } ZiplBootMode;
 
 extern ZiplBootMode boot_mode;
pc-bios/s390-ccw/secure-ipl.h +3 -0
index 950cd45b3c..723612b9ea 100644
@@ -83,6 +83,9 @@ static inline void zipl_secure_error(const char *message)
     case ZIPL_BOOT_MODE_SECURE_AUDIT:
         printf("AUDIT MODE WARNING: %s\n", message);
         break;
+    case ZIPL_BOOT_MODE_SECURE:
+        panic(message);
+        break;
     default:
         break;
     }
Signature · 1 line
2.54.0
#57 lore raw

Re: [PATCH v11 27/32] pc-bios/s390-ccw: Handle true secure IPL mode

Quoted 64 lines · Zhuoying Cai

When secure boot is enabled (-secure-boot on) and certificate(s) are provided, the boot operates in True Secure IPL mode.

Any verification error during True Secure IPL mode will cause the entire boot process to terminate.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities. If secure boot is enabled but no certificate is provided, the boot process will also terminate, as this is not a valid secure boot configuration.

Note: True Secure IPL mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
  docs/system/s390x/secure-ipl.rst | 13 +++++++++++++
  pc-bios/s390-ccw/bootmap.c       |  8 ++++++++
  pc-bios/s390-ccw/main.c          |  3 ++-
  pc-bios/s390-ccw/s390-ccw.h      |  1 +
  pc-bios/s390-ccw/secure-ipl.h    |  3 +++
  5 files changed, 27 insertions(+), 1 deletion(-)
docs/system/s390x/secure-ipl.rst +13 -0
index 9e3955f8fc..c8fb887ac0 100644
@@ -66,3 +66,16 @@ Configuration:
  .. code-block:: shell
 
      qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
+
+Secure Mode
+^^^^^^^^^^^
+
+When the ``secure-boot=on`` option is set and certificates are provided,
+a secure boot is performed with error reporting enabled. The boot process aborts
+if any error occurs.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/bootmap.c +2 -0
index a300fba8cd..8f54c15144 100644
@@ -738,6 +738,7 @@ static int zipl_run(ScsiBlockPtr *pte)
      case ZIPL_BOOT_MODE_NORMAL:
          rc = zipl_run_normal(&entry, tmp_sec);
          break;
+    case ZIPL_BOOT_MODE_SECURE:
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          rc = zipl_run_secure(&entry, tmp_sec);
          break;
@@ -1115,9 +1116,16 @@ ZiplBootMode get_boot_mode(uint8_t hdr_flags)
  {
      bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
      bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+    VCStorageSizeBlock *vcssb;
 
      if (!sipl_set && iplir_set) {

pc-bios/s390-ccw/bootmap.c ZiplBootMode get_boot_mode(uint8_t hdr_flags) · line 1131

Quoted 10 lines
pc-bios/s390-ccw/bootmap.c +6 -0
          return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    } else if (sipl_set && iplir_set) {
+        vcssb = zipl_secure_get_vcssb();
+        if (vcssb == NULL || vcssb->length == VCSSB_NO_VC) {
+            panic("Need at least one certificate for secure boot!");
+        }
+        return ZIPL_BOOT_MODE_SECURE;
      }
 
      return ZIPL_BOOT_MODE_NORMAL;

In main(), get_boot_mode() is called before the secure_ipl_supported() condition. Here, the call to zipl_secure_get_vcssb() fails disgracefully when using a cpu gen that does not support secure IPL.

Quoted 42 lines
pc-bios/s390-ccw/main.c +2 -1
index 0bcd32b059..e34179a05f 100644
@@ -396,9 +396,10 @@ void main(void)
 
      boot_mode = get_boot_mode(iplb->hdr_flags);
      switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE:
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          if (!secure_ipl_supported()) {
-            panic("Unable to boot in audit mode");
+            panic("Unable to boot in secure/audit mode");
          }
      default:
          break;
pc-bios/s390-ccw/s390-ccw.h +1 -0
index b66a9b50bf..7a7bf7720b 100644
@@ -90,6 +90,7 @@ void zipl_load(void);
  typedef enum ZiplBootMode {
      ZIPL_BOOT_MODE_NORMAL = 0,
      ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
+    ZIPL_BOOT_MODE_SECURE = 2,
  } ZiplBootMode;
 
  extern ZiplBootMode boot_mode;
pc-bios/s390-ccw/secure-ipl.h +3 -0
index 950cd45b3c..723612b9ea 100644
@@ -83,6 +83,9 @@ static inline void zipl_secure_error(const char *message)
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          printf("AUDIT MODE WARNING: %s\n", message);
          break;
+    case ZIPL_BOOT_MODE_SECURE:
+        panic(message);
+        break;
      default:
          break;
      }
#58 lore raw

Re: [PATCH v11 27/32] pc-bios/s390-ccw: Handle true secure IPL mode

Quoted 74 lines · Joshua Daley
Quoted 73 lines · Zhuoying Cai

When secure boot is enabled (-secure-boot on) and certificate(s) are provided, the boot operates in True Secure IPL mode.

Any verification error during True Secure IPL mode will cause the entire boot process to terminate.

Secure IPL in audit mode requires at least one certificate provided in the key store along with necessary facilities. If secure boot is enabled but no certificate is provided, the boot process will also terminate, as this is not a valid secure boot configuration.

Note: True Secure IPL mode is implemented for the SCSI scheme of virtio-blk/virtio-scsi devices.

---
  docs/system/s390x/secure-ipl.rst | 13 +++++++++++++
  pc-bios/s390-ccw/bootmap.c       |  8 ++++++++
  pc-bios/s390-ccw/main.c          |  3 ++-
  pc-bios/s390-ccw/s390-ccw.h      |  1 +
  pc-bios/s390-ccw/secure-ipl.h    |  3 +++
  5 files changed, 27 insertions(+), 1 deletion(-)
docs/system/s390x/secure-ipl.rst +13 -0
index 9e3955f8fc..c8fb887ac0 100644
@@ -66,3 +66,16 @@ Configuration:
  .. code-block:: shell
 
      qemu-system-s390x -machine s390-ccw-virtio,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
+
+Secure Mode
+^^^^^^^^^^^
+
+When the ``secure-boot=on`` option is set and certificates are provided,
+a secure boot is performed with error reporting enabled. The boot process aborts
+if any error occurs.
+
+Configuration:
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
pc-bios/s390-ccw/bootmap.c +8 -0
index a300fba8cd..8f54c15144 100644
@@ -738,6 +738,7 @@ static int zipl_run(ScsiBlockPtr *pte)
      case ZIPL_BOOT_MODE_NORMAL:
          rc = zipl_run_normal(&entry, tmp_sec);
          break;
+    case ZIPL_BOOT_MODE_SECURE:
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          rc = zipl_run_secure(&entry, tmp_sec);
          break;
@@ -1115,9 +1116,16 @@ ZiplBootMode get_boot_mode(uint8_t hdr_flags)
  {
      bool sipl_set = hdr_flags & DIAG308_IPIB_FLAGS_SIPL;
      bool iplir_set = hdr_flags & DIAG308_IPIB_FLAGS_IPLIR;
+    VCStorageSizeBlock *vcssb;
 
      if (!sipl_set && iplir_set) {
          return ZIPL_BOOT_MODE_SECURE_AUDIT;
+    } else if (sipl_set && iplir_set) {
+        vcssb = zipl_secure_get_vcssb();
+        if (vcssb == NULL || vcssb->length == VCSSB_NO_VC) {
+            panic("Need at least one certificate for secure boot!");
+        }
+        return ZIPL_BOOT_MODE_SECURE;
      }
 
Quoted 5 lines

pc-bios/s390-ccw/bootmap.c ZiplBootMode get_boot_mode(uint8_t hdr_flags) · line 1131

Quoted 1 line
pc-bios/s390-ccw/bootmap.c +0 -0
      return ZIPL_BOOT_MODE_NORMAL;

In main(), get_boot_mode() is called before the secure_ipl_supported() condition. Here, the call to zipl_secure_get_vcssb() fails disgracefully when using a cpu gen that does not support secure IPL.

Thanks for catching this. The is_cert_store_facility_supported() check and its handling should be added before calling zipl_secure_get_vcssb(). I'll fix it.

Quoted 43 lines
Quoted 42 lines
pc-bios/s390-ccw/main.c +2 -1
index 0bcd32b059..e34179a05f 100644
@@ -396,9 +396,10 @@ void main(void)
 
      boot_mode = get_boot_mode(iplb->hdr_flags);
      switch (boot_mode) {
+    case ZIPL_BOOT_MODE_SECURE:
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          if (!secure_ipl_supported()) {
-            panic("Unable to boot in audit mode");
+            panic("Unable to boot in secure/audit mode");
          }
      default:
          break;
pc-bios/s390-ccw/s390-ccw.h +1 -0
index b66a9b50bf..7a7bf7720b 100644
@@ -90,6 +90,7 @@ void zipl_load(void);
  typedef enum ZiplBootMode {
      ZIPL_BOOT_MODE_NORMAL = 0,
      ZIPL_BOOT_MODE_SECURE_AUDIT = 1,
+    ZIPL_BOOT_MODE_SECURE = 2,
  } ZiplBootMode;
 
  extern ZiplBootMode boot_mode;
pc-bios/s390-ccw/secure-ipl.h +3 -0
index 950cd45b3c..723612b9ea 100644
@@ -83,6 +83,9 @@ static inline void zipl_secure_error(const char *message)
      case ZIPL_BOOT_MODE_SECURE_AUDIT:
          printf("AUDIT MODE WARNING: %s\n", message);
          break;
+    case ZIPL_BOOT_MODE_SECURE:
+        panic(message);
+        break;
      default:
          break;
      }
#59 lore raw

PATCH v11 28/32 hw/s390x/ipl: Handle secure boot with multiple boot devices

In reply to Zhuoying Cai

The current approach to enable secure boot relies on providing secure-boot and boot-certs parameters of s390-ccw-virtio machine type option, which apply to all boot devices.

With the possibility of multiple boot devices, secure boot expects all provided devices to be supported and eligible (e.g., virtio-blk/virtio-scsi using the SCSI scheme).

If multiple boot devices are provided and include an unsupported (e.g., ECKD, VFIO) or a non-eligible (e.g., Net) device, the boot process will terminate with an error logged to the console.

---
 hw/s390x/ipl.c          | 79 ++++++++++++++++++++++++++++-------------
 pc-bios/s390-ccw/main.c |  3 --
 2 files changed, 54 insertions(+), 28 deletions(-)
hw/s390x/ipl.c +54 -25
index 67e8231c76..52f953fd32 100644
@@ -473,6 +473,58 @@ static bool s390_secure_boot_enabled(void)
     return S390_CCW_MACHINE(qdev_get_machine())->secure_boot;
 }
 
+static bool s390_validate_secure_boot_device(int devtype, Error **errp)
+{
+    switch (devtype) {
+    case CCW_DEVTYPE_VFIO:
+       error_setg(errp, "Passthrough (vfio) CCW device does not support secure boot!");
+       return false;
+    case CCW_DEVTYPE_VIRTIO_NET:
+       error_setg(errp, "Virtio net boot device does not support secure boot!");
+       return false;
+    default:
+       return true;
+    }
+}
+
+static void s390_apply_secure_boot(IplParameterBlock *iplb, int devtype,
+                                   bool secure_boot, bool audit_mode)
+{
+    Error *local_error = NULL;
+
+    if (!secure_boot && !audit_mode) {
+        return;
+    }
+
+    if (!s390_validate_secure_boot_device(devtype, &local_error)) {
+        error_report_err(local_error);
+        exit(1);
+    }
+
+    /*
+     * If secure-boot is enabled, then toggle the secure IPL flags (SIPL) to
+     * trigger secure boot in the s390 BIOS.
+     *
+     * Boot process will terminate if any error occurs during secure boot.
+     */
+    if (secure_boot) {
+        iplb->hdr_flags |= DIAG308_IPIB_FLAGS_SIPL;
+    }
+
+    /*
+     * For both secure boot and audit mode, enable the IPL Information
+     * Report (IPLIR) flag so that the firmware generates an IPL
+     * Information Report Block (IIRB).
+     *
+     * Results of secure boot will be stored in IIRB.
+     *
+     * Extend the IPL parameter block to its maximum length to ensure
+     * sufficient space for the BIOS to populate the IIRB.
+     */
+    iplb->hdr_flags |= DIAG308_IPIB_FLAGS_IPLIR;
+    iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
+}
+
 static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
 {
     CcwDevice *ccw_dev = NULL;
@@ -529,31 +581,8 @@ static bool s390_build_iplb(DeviceState *dev_st, IplParameterBlock *iplb)
         s390_ipl_convert_loadparm((char *)lp, iplb->loadparm);
         iplb->flags |= DIAG308_FLAGS_LP_VALID;
 
-        /*
-         * If secure-boot is enabled, then toggle the secure IPL flags to
-         * trigger secure boot in the s390 BIOS.
-         *
-         * Boot process will terminate if any error occurs during secure boot.
-         *
-         * If SIPL is on, IPLIR must also be on.
-         */
-        if (s390_secure_boot_enabled()) {
-            iplb->hdr_flags |= (DIAG308_IPIB_FLAGS_SIPL | DIAG308_IPIB_FLAGS_IPLIR);
-            iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
-        }
-        /*
-         * Secure boot in audit mode will perform
-         * if certificate(s) exist in the key store.
-         *
-         * IPL Information Report Block (IIRB) will exist
-         * for secure boot in audit mode.
-         *
-         * Results of secure boot will be stored in IIRB.
-         */
-        else if (s390_has_certificate()) {
-            iplb->hdr_flags |= DIAG308_IPIB_FLAGS_IPLIR;
-            iplb->len = cpu_to_be32(S390_IPLB_MAX_LEN);
-        }
+        s390_apply_secure_boot(iplb, devtype, s390_secure_boot_enabled(),
+                               s390_has_certificate());
 
         return true;
     }
pc-bios/s390-ccw/main.c +0 -3
index e34179a05f..2db3b704ab 100644
@@ -304,9 +304,6 @@ static void ipl_ccw_device(void)
     switch (cutype) {
     case CU_TYPE_DASD_3990:
     case CU_TYPE_DASD_2107:
-        IPL_assert((boot_mode == ZIPL_BOOT_MODE_NORMAL),
-                    "Passthrough (vfio) CCW device does not support secure boot!");
-
         dasd_ipl(blk_schid, cutype);
         break;
     case CU_TYPE_VIRTIO:
Signature · 1 line
2.54.0
#60 lore raw

PATCH v11 29/32 hw/s390x/ipl: Handle secure boot without specifying a boot device

In reply to Zhuoying Cai

If secure boot in audit mode or True Secure IPL mode is enabled without specifying a boot device, the boot process will terminate with an error.

---
 hw/s390x/ipl.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
hw/s390x/ipl.c +10 -0
index 52f953fd32..2eb3b4643b 100644
@@ -852,6 +852,16 @@ void s390_ipl_prepare_cpu(S390CPU *cpu)
         cpu->env.psw.addr = ipl->bios_start_addr;
         if (!ipl->iplb_valid) {
             ipl->iplb_valid = s390_init_all_iplbs(ipl);
+
+            /*
+             * Secure IPL without specifying a boot device.
+             * IPLB is not generated if no boot device is defined.
+             */
+            if ((s390_has_certificate() || s390_secure_boot_enabled()) &&
+                !ipl->iplb_valid) {
+                error_report("No boot device defined for Secure IPL");
+                exit(1);
+            }
         } else {
             ipl->qipl.chain_len = 0;
         }
Signature · 1 line
2.54.0
#61 lore raw

PATCH v11 30/32 tests/functional/s390x: Add secure IPL functional test

In reply to Zhuoying Cai

Add functional test for secure IPL.

---
 tests/functional/s390x/meson.build        |   2 +
 tests/functional/s390x/test_secure_ipl.py | 148 ++++++++++++++++++++++
 2 files changed, 150 insertions(+)
 create mode 100755 tests/functional/s390x/test_secure_ipl.py
tests/functional/s390x/meson.build +2 -0
index b065b666bc..01cb2d1d4c 100644
@@ -2,6 +2,7 @@
 
 test_s390x_timeouts = {
   'ccw_virtio' : 420,
+  'secure_ipl' : 280,
 }
 
 tests_s390x_system_quick = [
@@ -14,6 +15,7 @@ tests_s390x_system_thorough = [
   'ccw_virtio',
   'pxelinux',
   'replay',
+  'secure_ipl',
   'topology',
   'tuxrun',
 ]
tests/functional/s390x/test_secure_ipl.py new file +148 -0

148 lines not on this page · raw message

Signature · 1 line
2.54.0
#62 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

Quoted 14 lines · Zhuoying Cai

Add functional test for secure IPL.

---
 tests/functional/s390x/meson.build        |   2 +
 tests/functional/s390x/test_secure_ipl.py | 148 ++++++++++++++++++++++
 2 files changed, 150 insertions(+)
 create mode 100755 tests/functional/s390x/test_secure_ipl.py
tests/functional/s390x/meson.build +0 -0
index b065b666bc..01cb2d1d4c 100644

tests/functional/s390x/meson.build line 5

Quoted 4 lines
tests/functional/s390x/meson.build +1 -0
@@ -2,6 +2,7 @@
 
 test_s390x_timeouts = {
   'ccw_virtio' : 420,
+  'secure_ipl' : 280,

How'd you come up with this value?

Quoted 17 lines
tests/functional/s390x/meson.build +1 -0
 }
 
 tests_s390x_system_quick = [
@@ -14,6 +15,7 @@ tests_s390x_system_thorough = [
   'ccw_virtio',
   'pxelinux',
   'replay',
+  'secure_ipl',
   'topology',
   'tuxrun',
 ]
tests/functional/s390x/test_secure_ipl.py new file +0 -0
new file mode 100755
index 0000000000..0980daace1

tests/functional/s390x/test_secure_ipl.py line 5

Quoted 5 lines
tests/functional/s390x/test_secure_ipl.py new file +5 -0
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+#
+# s390x Secure IPL functional test: validates secure-boot verification results
+#
+# SPDX-License-Identifier: GPL-2.0-or-later

A general comment, you'll need some form of docstring for the entire file, and any classes/methods defined later on.

Quoted 16 lines
tests/functional/s390x/test_secure_ipl.py new file +16 -0
+
+from subprocess import check_call, DEVNULL
+
+from qemu_test import QemuSystemTest, Asset, get_qemu_img
+from qemu_test import exec_command_and_wait_for_pattern, exec_command
+from qemu_test import wait_for_console_pattern, skipBigDataTest
+
+class S390xSecureIpl(QemuSystemTest):
+    ASSET_F40_QCOW2 = Asset(
+        ('https://archives.fedoraproject.org/pub/archive/'
+         'fedora-secondary/releases/40/Server/s390x/images/'
+         'Fedora-Server-KVM-40-1.14.s390x.qcow2'),
+        '091c232a7301be14e19c76ce9a0c1cbd2be2c4157884a731e1fc4f89e7455a5f')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

tests/functional/s390x/test_secure_ipl.py line 31

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        self.root_password = None
+        self.qcow2_path = None
+        self.cert_path = None
+        self.prompt = None
+
+    # Boot a temporary VM to set up secure IPL image:
+    # - Create certificate
+    # - Sign stage3 binary and kernel
+    # - Run zipl
+    # - Extract certificate

Can we break out those four chunks into standalone routines, so that we can identify them individually rather than as part of the novella that follows?

Quoted 41 lines
tests/functional/s390x/test_secure_ipl.py new file +41 -0
+    def setup_s390x_secure_ipl(self):
+        temp_vm = self.get_vm(name='sipl_setup')
+        temp_vm.set_machine('s390-ccw-virtio')
+
+        asset_path = self.ASSET_F40_QCOW2.fetch()
+        self.qcow2_path = self.scratch_file('f40.qcow2')
+        qemu_img = get_qemu_img(self)
+        check_call([qemu_img, 'create', '-f', 'qcow2', '-b', asset_path,
+                    '-F', 'qcow2', self.qcow2_path], stdout=DEVNULL, stderr=DEVNULL)
+
+        temp_vm.set_console()
+        temp_vm.add_args('-nographic',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
+                         f'id=drive0,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive0,bootindex=1')
+        temp_vm.launch()
+
+        # Initial root account setup (Fedora first boot screen)
+        self.root_password = 'fedora40password'
+        wait_for_console_pattern(self, 'Please make a selection from the above',
+                                 vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, '4', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                          'Password (confirm):', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                    'Please make a selection from the above',
+                                    vm=temp_vm)
+
+        # Login as root
+        self.prompt = '[root@localhost ~]#'
+        exec_command_and_wait_for_pattern(self, 'c', 'localhost login:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt,
+                                          vm=temp_vm)
+
+        # Certificate generation
+        exec_command_and_wait_for_pattern(self,
+                                          'openssl version', 'OpenSSL 3.2.1 30',
+                                          vm=temp_vm)

tests/functional/s390x/test_secure_ipl.py line 82

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        exec_command_and_wait_for_pattern(self,
+                            'openssl req -new -x509 -newkey rsa:2048 '
+                            '-keyout mykey.pem -outform PEM -out mycert.pem '
+                            '-days 36500 -subj "/CN=My Name/" -nodes -verbose',
+                            'Writing private key to \'mykey.pem\'', vm=temp_vm)
+
+        # Install kernel-devel (needed for sign-file)
+        exec_command_and_wait_for_pattern(self,
+                                'sudo dnf install kernel-devel-$(uname -r) -y',
+                                'Complete!', vm=temp_vm)

This is the last thing I see in base.log when running this test on my system. Looking at console log, this errors out:

2026-06-03 20:08:33,829: ^[[?2004h[root@localhost ~]# sudo dnf install kernel-devel-$(uname -r) -y
2026-06-03 20:08:34,147: ^[[?2004l^MFedora 40 - s390x        [===                 ] ---  B/s |   0 
B     --:-- ETA^MFedora 40 - s390x                               0.0  B/s |   0  B     00:00
2026-06-03 20:08:34,147: Errors during downloading metadata for repository 'fedora':
2026-06-03 20:08:34,147: - Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]
2026-06-03 20:08:34,207: Error: Failed to download metadata for repo 'fedora': Cannot prepare

internal mirrorlist: Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]

Surrounding this, I'm noting that this is surrounded by messages from NetworkManager waiting for it to come online, so maybe there needs to be a check that there's actually a network here, so we can bail out rather than timeout.

Quoted 66 lines
tests/functional/s390x/test_secure_ipl.py new file +66 -0
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command_and_wait_for_pattern(self,
+                                    'ls /usr/src/kernels/$(uname -r)/scripts/',
+                                    'sign-file', vm=temp_vm)
+
+        # Sign stage3 binary and kernel
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /lib/s390-tools/stage3.bin',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /boot/vmlinuz-$(uname -r)',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+
+        # Run zipl to prepare for secure boot
+        exec_command_and_wait_for_pattern(self, 'zipl --secure 1 -VV', 'Done.',
+                                          vm=temp_vm)
+
+        # Extract certificate to host
+        out = exec_command_and_wait_for_pattern(self, 'cat mycert.pem',
+                                                '-----END CERTIFICATE-----',
+                                                vm=temp_vm)
+        # strip first line to avoid console echo artifacts
+        cert = "\n".join(out.decode("utf-8").splitlines()[1:])
+        self.log.info("%s", cert)
+
+        self.cert_path = self.scratch_file("mycert.pem")
+
+        with open(self.cert_path, 'w', encoding="utf-8") as file_object:
+            file_object.write(cert)
+
+        # Shutdown temp vm
+        temp_vm.shutdown()
+
+    @skipBigDataTest()
+    def test_s390x_secure_ipl(self):
+        self.require_accelerator('kvm')
+        self.setup_s390x_secure_ipl()
+
+        self.set_machine('s390-ccw-virtio')
+
+        self.vm.set_console()
+        self.vm.add_args('-nographic',
+                         '-machine', 's390-ccw-virtio,secure-boot=on,'
+                         f'boot-certs.0.path={self.cert_path}',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
+                         f'id=drive1,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive1,bootindex=1')
+        self.vm.launch()
+
+        # Expect two verified components
+        verified_output = "Verified component"
+        wait_for_console_pattern(self, verified_output)
+        wait_for_console_pattern(self, verified_output)
+
+        # Login and verify the vm is booted using secure boot
+        wait_for_console_pattern(self, 'localhost login:')
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:')
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt)
+        exec_command_and_wait_for_pattern(self, 'cat /sys/firmware/ipl/secure', '1')
+
+if __name__ == '__main__':
+    QemuSystemTest.main()
#63 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

Quoted 141 lines · Eric Farman
Quoted 14 lines · Zhuoying Cai

Add functional test for secure IPL.

---
 tests/functional/s390x/meson.build        |   2 +
 tests/functional/s390x/test_secure_ipl.py | 148 ++++++++++++++++++++++
 2 files changed, 150 insertions(+)
 create mode 100755 tests/functional/s390x/test_secure_ipl.py
tests/functional/s390x/meson.build +0 -0
index b065b666bc..01cb2d1d4c 100644

tests/functional/s390x/meson.build line 5

Quoted 4 lines
tests/functional/s390x/meson.build +1 -0
@@ -2,6 +2,7 @@
 
 test_s390x_timeouts = {
   'ccw_virtio' : 420,
+  'secure_ipl' : 280,

How'd you come up with this value?

Quoted 17 lines
tests/functional/s390x/meson.build +1 -0
 }
 
 tests_s390x_system_quick = [
@@ -14,6 +15,7 @@ tests_s390x_system_thorough = [
   'ccw_virtio',
   'pxelinux',
   'replay',
+  'secure_ipl',
   'topology',
   'tuxrun',
 ]
tests/functional/s390x/test_secure_ipl.py new file +0 -0
new file mode 100755
index 0000000000..0980daace1

tests/functional/s390x/test_secure_ipl.py line 5

Quoted 5 lines
tests/functional/s390x/test_secure_ipl.py new file +5 -0
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+#
+# s390x Secure IPL functional test: validates secure-boot verification results
+#
+# SPDX-License-Identifier: GPL-2.0-or-later

A general comment, you'll need some form of docstring for the entire file, and any classes/methods defined later on.

Quoted 16 lines
tests/functional/s390x/test_secure_ipl.py new file +16 -0
+
+from subprocess import check_call, DEVNULL
+
+from qemu_test import QemuSystemTest, Asset, get_qemu_img
+from qemu_test import exec_command_and_wait_for_pattern, exec_command
+from qemu_test import wait_for_console_pattern, skipBigDataTest
+
+class S390xSecureIpl(QemuSystemTest):
+    ASSET_F40_QCOW2 = Asset(
+        ('https://archives.fedoraproject.org/pub/archive/'
+         'fedora-secondary/releases/40/Server/s390x/images/'
+         'Fedora-Server-KVM-40-1.14.s390x.qcow2'),
+        '091c232a7301be14e19c76ce9a0c1cbd2be2c4157884a731e1fc4f89e7455a5f')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

tests/functional/s390x/test_secure_ipl.py line 31

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        self.root_password = None
+        self.qcow2_path = None
+        self.cert_path = None
+        self.prompt = None
+
+    # Boot a temporary VM to set up secure IPL image:
+    # - Create certificate
+    # - Sign stage3 binary and kernel
+    # - Run zipl
+    # - Extract certificate

Can we break out those four chunks into standalone routines, so that we can identify them individually rather than as part of the novella that follows?

Quoted 41 lines
tests/functional/s390x/test_secure_ipl.py new file +41 -0
+    def setup_s390x_secure_ipl(self):
+        temp_vm = self.get_vm(name='sipl_setup')
+        temp_vm.set_machine('s390-ccw-virtio')
+
+        asset_path = self.ASSET_F40_QCOW2.fetch()
+        self.qcow2_path = self.scratch_file('f40.qcow2')
+        qemu_img = get_qemu_img(self)
+        check_call([qemu_img, 'create', '-f', 'qcow2', '-b', asset_path,
+                    '-F', 'qcow2', self.qcow2_path], stdout=DEVNULL, stderr=DEVNULL)
+
+        temp_vm.set_console()
+        temp_vm.add_args('-nographic',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
+                         f'id=drive0,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive0,bootindex=1')
+        temp_vm.launch()
+
+        # Initial root account setup (Fedora first boot screen)
+        self.root_password = 'fedora40password'
+        wait_for_console_pattern(self, 'Please make a selection from the above',
+                                 vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, '4', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                          'Password (confirm):', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                    'Please make a selection from the above',
+                                    vm=temp_vm)
+
+        # Login as root
+        self.prompt = '[root@localhost ~]#'
+        exec_command_and_wait_for_pattern(self, 'c', 'localhost login:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt,
+                                          vm=temp_vm)
+
+        # Certificate generation
+        exec_command_and_wait_for_pattern(self,
+                                          'openssl version', 'OpenSSL 3.2.1 30',
+                                          vm=temp_vm)

tests/functional/s390x/test_secure_ipl.py line 82

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        exec_command_and_wait_for_pattern(self,
+                            'openssl req -new -x509 -newkey rsa:2048 '
+                            '-keyout mykey.pem -outform PEM -out mycert.pem '
+                            '-days 36500 -subj "/CN=My Name/" -nodes -verbose',
+                            'Writing private key to \'mykey.pem\'', vm=temp_vm)
+
+        # Install kernel-devel (needed for sign-file)
+        exec_command_and_wait_for_pattern(self,
+                                'sudo dnf install kernel-devel-$(uname -r) -y',
+                                'Complete!', vm=temp_vm)

This is the last thing I see in base.log when running this test on my system. Looking at console log, this errors out:

2026-06-03 20:08:33,829: ^[[?2004h[root@localhost ~]# sudo dnf install kernel-devel-$(uname -r) -y
2026-06-03 20:08:34,147: ^[[?2004l^MFedora 40 - s390x        [===                 ] ---  B/s |   0 
B     --:-- ETA^MFedora 40 - s390x                               0.0  B/s |   0  B     00:00
2026-06-03 20:08:34,147: Errors during downloading metadata for repository 'fedora':
2026-06-03 20:08:34,147: - Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]
2026-06-03 20:08:34,207: Error: Failed to download metadata for repo 'fedora': Cannot prepare
Quoted 8 lines

internal mirrorlist: Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]

Surrounding this, I'm noting that this is surrounded by messages from NetworkManager waiting for it to come online, so maybe there needs to be a check that there's actually a network here, so we can bail out rather than timeout.

Josh suggested (thank you!!) that perhaps I didn't have slirp enabled in my build when I tried this, which is indeed the cause for my hangup. Easy fix on my side, but it's a dependency that maybe you can account for in this test (or maybe -net none, if you dont need to connect it to anything?).

Of course, remedying THAT problem gives me yet another error which I haven't chased down. Looks like the first of these [*] failed later on. This is a particularly crusty system I'm using, so maybe it's simply another thing that is missing.

Quoted 50 lines
Quoted 50 lines
tests/functional/s390x/test_secure_ipl.py new file +49 -0
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command_and_wait_for_pattern(self,
+                                    'ls /usr/src/kernels/$(uname -r)/scripts/',
+                                    'sign-file', vm=temp_vm)
+
+        # Sign stage3 binary and kernel
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /lib/s390-tools/stage3.bin',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /boot/vmlinuz-$(uname -r)',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+
+        # Run zipl to prepare for secure boot
+        exec_command_and_wait_for_pattern(self, 'zipl --secure 1 -VV', 'Done.',
+                                          vm=temp_vm)
+
+        # Extract certificate to host
+        out = exec_command_and_wait_for_pattern(self, 'cat mycert.pem',
+                                                '-----END CERTIFICATE-----',
+                                                vm=temp_vm)
+        # strip first line to avoid console echo artifacts
+        cert = "\n".join(out.decode("utf-8").splitlines()[1:])
+        self.log.info("%s", cert)
+
+        self.cert_path = self.scratch_file("mycert.pem")
+
+        with open(self.cert_path, 'w', encoding="utf-8") as file_object:
+            file_object.write(cert)
+
+        # Shutdown temp vm
+        temp_vm.shutdown()
+
+    @skipBigDataTest()
+    def test_s390x_secure_ipl(self):
+        self.require_accelerator('kvm')
+        self.setup_s390x_secure_ipl()
+
+        self.set_machine('s390-ccw-virtio')
+
+        self.vm.set_console()
+        self.vm.add_args('-nographic',
+                         '-machine', 's390-ccw-virtio,secure-boot=on,'
+                         f'boot-certs.0.path={self.cert_path}',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
Quoted 8 lines

tests/functional/s390x/test_secure_ipl.py line 139

Quoted 8 lines
tests/functional/s390x/test_secure_ipl.py new file +8 -0
+                         f'id=drive1,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive1,bootindex=1')
+        self.vm.launch()
+
+        # Expect two verified components
+        verified_output = "Verified component"
+        wait_for_console_pattern(self, verified_output)
+        wait_for_console_pattern(self, verified_output)

[*] Failure occurs here, because guest panicked. Surely it's something not set up correctly on the guest that was created, because it's happening as soon as it tries to kick over to the guest kernel, but I don't see any errors in the log that suggests anything amiss:

console.log:
...

2026-06-05 17:51:03,344: -----END CERTIFICATE-----
2026-06-05 17:51:03,398: LOADPARM=[        ]
2026-06-05 17:51:03,398:
2026-06-05 17:51:03,398: Using virtio-blk.
2026-06-05 17:51:03,399: Using SCSI scheme.
2026-06-05 17:51:03,408: ..........

base.log:
...

2026-06-05 17:51:03,398 - DEBUG: qemu.qmp.protocol.default._set_state Transitioning from
'Runstate.CONNECTING' to 'Runstate.RUNNING'.
2026-06-05 17:51:03,398 - DEBUG: qemu-test._console_interaction Console interaction:
success_msg='Verified component' failure_msg='None' send_string='None'
2026-06-05 17:51:03,398 - DEBUG: qemu.machine.machine.console_socket Opening console socket
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine.shutdown Shutting down VM appliance;
timeout=30
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine._soft_shutdown Attempting graceful termination
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine._early_cleanup Closing console socket
2026-06-05 17:51:03,411 - DEBUG: qemu.machine.machine._soft_shutdown Politely asking QEMU to
terminate
2026-06-05 17:51:03,411 - DEBUG: qemu.qmp.protocol.default._cb_outbound --> {
  "execute": "quit"
}
2026-06-05 17:51:03,411 - DEBUG: qemu.qmp.protocol.default._cb_inbound <-- {
  "timestamp": {
    "seconds": 1780674663,
    "microseconds": 409153
  },
  "event": "GUEST_PANICKED",
  "data": {
    "action": "poweroff",
    "info": {
      "core": 0,
      "psw-addr": 17682,
      "reason": "disabled-wait",
      "psw-mask": 562952100904960,
      "type": "s390"
    }
  }

}

Quoted 9 lines
Quoted 9 lines
tests/functional/s390x/test_secure_ipl.py new file +9 -0
+
+        # Login and verify the vm is booted using secure boot
+        wait_for_console_pattern(self, 'localhost login:')
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:')
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt)
+        exec_command_and_wait_for_pattern(self, 'cat /sys/firmware/ipl/secure', '1')
+
+if __name__ == '__main__':
+    QemuSystemTest.main()
#64 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

Thanks for the feedback!

Quoted 17 lines · Eric Farman
Quoted 16 lines · Eric Farman
Quoted 15 lines · Zhuoying Cai

Add functional test for secure IPL.

---
 tests/functional/s390x/meson.build        |   2 +
 tests/functional/s390x/test_secure_ipl.py | 148 ++++++++++++++++++++++
 2 files changed, 150 insertions(+)
 create mode 100755 tests/functional/s390x/test_secure_ipl.py
tests/functional/s390x/meson.build +0 -0
index b065b666bc..01cb2d1d4c 100644
@@ -2,6 +2,7 @@
 
Quoted 6 lines
Quoted 6 lines

tests/functional/s390x/meson.build line 5

Quoted 3 lines
tests/functional/s390x/meson.build +1 -0
 test_s390x_timeouts = {
   'ccw_virtio' : 420,
+  'secure_ipl' : 280,

How'd you come up with this value?

I based it on previous test runs where the test consistently completed within 200 seconds, so I set the timeout to 280 seconds to provide some buffer.

However, I’ve noticed that when the cached qcow2 file is deleted and the test is run repeatedly, the download time can vary significantly and sometimes exceed this limit, leading to timeouts.

I’m not sure what the best approach is here — whether to increase the timeout further or remove it entirely. Do you have any recommendations?

Quoted 124 lines
Quoted 124 lines
Quoted 17 lines
tests/functional/s390x/meson.build +1 -0
 }
 
 tests_s390x_system_quick = [
@@ -14,6 +15,7 @@ tests_s390x_system_thorough = [
   'ccw_virtio',
   'pxelinux',
   'replay',
+  'secure_ipl',
   'topology',
   'tuxrun',
 ]
tests/functional/s390x/test_secure_ipl.py new file +0 -0
new file mode 100755
index 0000000000..0980daace1

tests/functional/s390x/test_secure_ipl.py line 5

Quoted 5 lines
tests/functional/s390x/test_secure_ipl.py new file +5 -0
@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+#
+# s390x Secure IPL functional test: validates secure-boot verification results
+#
+# SPDX-License-Identifier: GPL-2.0-or-later

A general comment, you'll need some form of docstring for the entire file, and any classes/methods defined later on.

Quoted 16 lines
tests/functional/s390x/test_secure_ipl.py new file +16 -0
+
+from subprocess import check_call, DEVNULL
+
+from qemu_test import QemuSystemTest, Asset, get_qemu_img
+from qemu_test import exec_command_and_wait_for_pattern, exec_command
+from qemu_test import wait_for_console_pattern, skipBigDataTest
+
+class S390xSecureIpl(QemuSystemTest):
+    ASSET_F40_QCOW2 = Asset(
+        ('https://archives.fedoraproject.org/pub/archive/'
+         'fedora-secondary/releases/40/Server/s390x/images/'
+         'Fedora-Server-KVM-40-1.14.s390x.qcow2'),
+        '091c232a7301be14e19c76ce9a0c1cbd2be2c4157884a731e1fc4f89e7455a5f')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

tests/functional/s390x/test_secure_ipl.py line 31

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        self.root_password = None
+        self.qcow2_path = None
+        self.cert_path = None
+        self.prompt = None
+
+    # Boot a temporary VM to set up secure IPL image:
+    # - Create certificate
+    # - Sign stage3 binary and kernel
+    # - Run zipl
+    # - Extract certificate

Can we break out those four chunks into standalone routines, so that we can identify them individually rather than as part of the novella that follows?

Quoted 41 lines
tests/functional/s390x/test_secure_ipl.py new file +41 -0
+    def setup_s390x_secure_ipl(self):
+        temp_vm = self.get_vm(name='sipl_setup')
+        temp_vm.set_machine('s390-ccw-virtio')
+
+        asset_path = self.ASSET_F40_QCOW2.fetch()
+        self.qcow2_path = self.scratch_file('f40.qcow2')
+        qemu_img = get_qemu_img(self)
+        check_call([qemu_img, 'create', '-f', 'qcow2', '-b', asset_path,
+                    '-F', 'qcow2', self.qcow2_path], stdout=DEVNULL, stderr=DEVNULL)
+
+        temp_vm.set_console()
+        temp_vm.add_args('-nographic',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
+                         f'id=drive0,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive0,bootindex=1')
+        temp_vm.launch()
+
+        # Initial root account setup (Fedora first boot screen)
+        self.root_password = 'fedora40password'
+        wait_for_console_pattern(self, 'Please make a selection from the above',
+                                 vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, '4', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                          'Password (confirm):', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password,
+                                    'Please make a selection from the above',
+                                    vm=temp_vm)
+
+        # Login as root
+        self.prompt = '[root@localhost ~]#'
+        exec_command_and_wait_for_pattern(self, 'c', 'localhost login:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:', vm=temp_vm)
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt,
+                                          vm=temp_vm)
+
+        # Certificate generation
+        exec_command_and_wait_for_pattern(self,
+                                          'openssl version', 'OpenSSL 3.2.1 30',
+                                          vm=temp_vm)

tests/functional/s390x/test_secure_ipl.py line 82

Quoted 10 lines
tests/functional/s390x/test_secure_ipl.py new file +10 -0
+        exec_command_and_wait_for_pattern(self,
+                            'openssl req -new -x509 -newkey rsa:2048 '
+                            '-keyout mykey.pem -outform PEM -out mycert.pem '
+                            '-days 36500 -subj "/CN=My Name/" -nodes -verbose',
+                            'Writing private key to \'mykey.pem\'', vm=temp_vm)
+
+        # Install kernel-devel (needed for sign-file)
+        exec_command_and_wait_for_pattern(self,
+                                'sudo dnf install kernel-devel-$(uname -r) -y',
+                                'Complete!', vm=temp_vm)

This is the last thing I see in base.log when running this test on my system. Looking at console log, this errors out:

2026-06-03 20:08:33,829: ^[[?2004h[root@localhost ~]# sudo dnf install kernel-devel-$(uname -r) -y
2026-06-03 20:08:34,147: ^[[?2004l^MFedora 40 - s390x        [===                 ] ---  B/s |   0 
B     --:-- ETA^MFedora 40 - s390x                               0.0  B/s |   0  B     00:00
2026-06-03 20:08:34,147: Errors during downloading metadata for repository 'fedora':
2026-06-03 20:08:34,147: - Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]
2026-06-03 20:08:34,207: Error: Failed to download metadata for repo 'fedora': Cannot prepare

internal mirrorlist: Curl error (6): Couldn't resolve host name for
https://mirrors.fedoraproject.org/metalink?repo=fedora-40&arch=s390x [Could not resolve host:
mirrors.fedoraproject.org]

Quoted 8 lines
Quoted 3 lines

Surrounding this, I'm noting that this is surrounded by messages from NetworkManager waiting for it to come online, so maybe there needs to be a check that there's actually a network here, so we can bail out rather than timeout.

Josh suggested (thank you!!) that perhaps I didn't have slirp enabled in my build when I tried this, which is indeed the cause for my hangup. Easy fix on my side, but it's a dependency that maybe you can account for in this test (or maybe -net none, if you dont need to connect it to anything?).

slirp is a dependency since the guest needs network access to download packages. Thanks to Josh for pointing that out.

I’ll add a check during test setup to ensure slirp is enabled so this dependency is handled explicitly.

Quoted 108 lines

Of course, remedying THAT problem gives me yet another error which I haven't chased down. Looks like the first of these [*] failed later on. This is a particularly crusty system I'm using, so maybe it's simply another thing that is missing.

Quoted 50 lines
Quoted 50 lines
tests/functional/s390x/test_secure_ipl.py new file +49 -0
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command_and_wait_for_pattern(self,
+                                    'ls /usr/src/kernels/$(uname -r)/scripts/',
+                                    'sign-file', vm=temp_vm)
+
+        # Sign stage3 binary and kernel
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /lib/s390-tools/stage3.bin',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+        exec_command(self, '/usr/src/kernels/$(uname -r)/scripts/sign-file '
+                    'sha256 mykey.pem mycert.pem /boot/vmlinuz-$(uname -r)',
+                    vm=temp_vm)
+        wait_for_console_pattern(self, self.prompt, vm=temp_vm)
+
+        # Run zipl to prepare for secure boot
+        exec_command_and_wait_for_pattern(self, 'zipl --secure 1 -VV', 'Done.',
+                                          vm=temp_vm)
+
+        # Extract certificate to host
+        out = exec_command_and_wait_for_pattern(self, 'cat mycert.pem',
+                                                '-----END CERTIFICATE-----',
+                                                vm=temp_vm)
+        # strip first line to avoid console echo artifacts
+        cert = "\n".join(out.decode("utf-8").splitlines()[1:])
+        self.log.info("%s", cert)
+
+        self.cert_path = self.scratch_file("mycert.pem")
+
+        with open(self.cert_path, 'w', encoding="utf-8") as file_object:
+            file_object.write(cert)
+
+        # Shutdown temp vm
+        temp_vm.shutdown()
+
+    @skipBigDataTest()
+    def test_s390x_secure_ipl(self):
+        self.require_accelerator('kvm')
+        self.setup_s390x_secure_ipl()
+
+        self.set_machine('s390-ccw-virtio')
+
+        self.vm.set_console()
+        self.vm.add_args('-nographic',
+                         '-machine', 's390-ccw-virtio,secure-boot=on,'
+                         f'boot-certs.0.path={self.cert_path}',
+                         '-accel', 'kvm',
+                         '-m', '1024',
+                         '-drive',
Quoted 8 lines

tests/functional/s390x/test_secure_ipl.py line 139

Quoted 8 lines
tests/functional/s390x/test_secure_ipl.py new file +8 -0
+                         f'id=drive1,if=none,format=qcow2,file={self.qcow2_path}',
+                         '-device', 'virtio-blk-ccw,drive=drive1,bootindex=1')
+        self.vm.launch()
+
+        # Expect two verified components
+        verified_output = "Verified component"
+        wait_for_console_pattern(self, verified_output)
+        wait_for_console_pattern(self, verified_output)

[*] Failure occurs here, because guest panicked. Surely it's something not set up correctly on the guest that was created, because it's happening as soon as it tries to kick over to the guest kernel, but I don't see any errors in the log that suggests anything amiss:

console.log:
...

2026-06-05 17:51:03,344: -----END CERTIFICATE-----
2026-06-05 17:51:03,398: LOADPARM=[        ]
2026-06-05 17:51:03,398:
2026-06-05 17:51:03,398: Using virtio-blk.
2026-06-05 17:51:03,399: Using SCSI scheme.
2026-06-05 17:51:03,408: ..........

base.log:
...

2026-06-05 17:51:03,398 - DEBUG: qemu.qmp.protocol.default._set_state Transitioning from
'Runstate.CONNECTING' to 'Runstate.RUNNING'.
2026-06-05 17:51:03,398 - DEBUG: qemu-test._console_interaction Console interaction:
success_msg='Verified component' failure_msg='None' send_string='None'
2026-06-05 17:51:03,398 - DEBUG: qemu.machine.machine.console_socket Opening console socket
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine.shutdown Shutting down VM appliance;
timeout=30
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine._soft_shutdown Attempting graceful termination
2026-06-05 17:51:03,410 - DEBUG: qemu.machine.machine._early_cleanup Closing console socket
2026-06-05 17:51:03,411 - DEBUG: qemu.machine.machine._soft_shutdown Politely asking QEMU to
terminate
2026-06-05 17:51:03,411 - DEBUG: qemu.qmp.protocol.default._cb_outbound --> {
  "execute": "quit"
}
2026-06-05 17:51:03,411 - DEBUG: qemu.qmp.protocol.default._cb_inbound <-- {
  "timestamp": {
    "seconds": 1780674663,
    "microseconds": 409153
  },
  "event": "GUEST_PANICKED",
  "data": {
    "action": "poweroff",
    "info": {
      "core": 0,
      "psw-addr": 17682,
      "reason": "disabled-wait",
      "psw-mask": 562952100904960,
      "type": "s390"
    }
  }
Quoted 3 lines

}

The console.log should look like this when the guest components are successfully verified:
...

2026-06-05 20:34:33,447: -----END CERTIFICATE-----
2026-06-05 20:34:33,851: LOADPARM=[        ]
2026-06-05 20:34:33,851:
2026-06-05 20:34:33,852: Using virtio-blk.
2026-06-05 20:34:33,854: Using SCSI scheme.
2026-06-05 20:34:33,856: ....Verified component
2026-06-05 20:34:33,856:
2026-06-05 20:34:34,307: ....Verified component
2026-06-05 20:34:34,307:
2026-06-05 20:34:34,316: ....

In your console.log, it looks like the components are being loaded, but the verification step is not performed. This might be because the test is not using the built BIOS image?

For reference, here are the build steps I used:

# ninja -C build
# make -C build/pc-bios/s390-ccw
# cp build/pc-bios/s390-ccw/s390-ccw.img pc-bios
# make install
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
tests/functional/s390x/test_secure_ipl.py new file +9 -0
+
+        # Login and verify the vm is booted using secure boot
+        wait_for_console_pattern(self, 'localhost login:')
+        exec_command_and_wait_for_pattern(self, 'root', 'Password:')
+        exec_command_and_wait_for_pattern(self, self.root_password, self.prompt)
+        exec_command_and_wait_for_pattern(self, 'cat /sys/firmware/ipl/secure', '1')
+
+if __name__ == '__main__':
+    QemuSystemTest.main()
#65 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

Quoted 3 lines · Zhuoying Cai

In your console.log, it looks like the components are being loaded, but the verification step is not performed. This might be because the test is not using the built BIOS image?

Ah, of course. I missed this bringing the system back online I was using for your changes. Sorry, must've been Friday. :)

Quoted 6 lines

For reference, here are the build steps I used:

# ninja -C build
# make -C build/pc-bios/s390-ccw
# cp build/pc-bios/s390-ccw/s390-ccw.img pc-bios
# make install
#66 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

In reply to Eric Farman
Quoted 2 lines · Eric Farman
Quoted 1 line · Zhuoying Cai

Add functional test for secure IPL.

...

Quoted 6 lines
Quoted 6 lines
tests/functional/s390x/test_secure_ipl.py new file +0 -0
new file mode 100755
index 0000000000..0980daace1
@@ -0,0 +1,148 @@
Quoted 8 lines

tests/functional/s390x/test_secure_ipl.py line 5

Quoted 5 lines
tests/functional/s390x/test_secure_ipl.py new file +5 -0
+#!/usr/bin/env python3
+#
+# s390x Secure IPL functional test: validates secure-boot verification results
+#
+# SPDX-License-Identifier: GPL-2.0-or-later

A general comment, you'll need some form of docstring for the entire file, and any classes/methods defined later on.

Yes, please make sure that the "pylint" does not complain about your file (minimum is "pylint --rcfile tests/functional/pylintrc ...", better is without the rc file).

Thanks,
Thomas

#67 lore raw

Re: [PATCH v11 30/32] tests/functional/s390x: Add secure IPL functional test

Quoted 19 lines · Thomas Huth
Quoted 2 lines · Eric Farman
Quoted 1 line · Zhuoying Cai

Add functional test for secure IPL.

...

Quoted 6 lines
Quoted 6 lines
tests/functional/s390x/test_secure_ipl.py new file +0 -0
new file mode 100755
index 0000000000..0980daace1
@@ -0,0 +1,148 @@
Quoted 8 lines

tests/functional/s390x/test_secure_ipl.py line 5

Quoted 5 lines
tests/functional/s390x/test_secure_ipl.py new file +5 -0
+#!/usr/bin/env python3
+#
+# s390x Secure IPL functional test: validates secure-boot verification results
+#
+# SPDX-License-Identifier: GPL-2.0-or-later

A general comment, you'll need some form of docstring for the entire file, and any classes/methods defined later on.

Quoted 7 lines

Yes, please make sure that the "pylint" does not complain about your file (minimum is "pylint --rcfile tests/functional/pylintrc ...", better is without the rc file).

Thanks,
Thomas

Thank you for the feedback! I’ll add docstrings to all classes and methods and make sure the file passes pylint checks in the next version.

#68 lore raw

PATCH v11 31/32 docs/specs: Add secure IPL documentation

In reply to Zhuoying Cai

Add documentation for secure IPL

---
 docs/specs/s390x-secure-ipl.rst | 55 +++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
docs/specs/s390x-secure-ipl.rst +55 -0
index 5fc15be99c..f4602fe19d 100644
@@ -1,5 +1,60 @@
 .. SPDX-License-Identifier: GPL-2.0-or-later
 
+s390 Secure IPL
+===============
+
+Secure IPL (a.k.a. secure boot) enables s390-ccw virtual machines to
+leverage qcrypto libraries and z/Architecture emulations to verify the
+integrity of signed kernels. The qcrypto libraries are used to perform
+certificate validation and signature-verification, whereas the
+z/Architecture emulations are used to ensure secure IPL data has not
+been tampered with, convey data between QEMU and guest code, and set up
+the relevant secure IPL data structures with verification results.
+
+To find out more about using this feature, see
+:doc:`documentation </system/s390x/secure-ipl>`.
+
+Note that "guest code" will refer to the s390-ccw BIOS unless stated
+otherwise.
+
+Both QEMU and guest code work in cooperation to perform secure IPL. The Secure
+Loading Attributes Facility (SCLAF) is used to check the Secure Code
+Loading Attribute Block (SCLAB) and ensure that secure IPL data has not
+been tampered with. DIAGNOSE 'X'320' is invoked by guest code to query
+the certificate store info and retrieve specific certificates from QEMU.
+DIAGNOSE 'X'508' is used by guest code to leverage qcrypto libraries to
+perform signature-verification in QEMU. Lastly, guest code generates and
+appends an IPL Information Report Block (IIRB) at the end of the IPL
+Parameter Block, which is used by the kernel to store signed and
+verified entries.
+
+The logical steps are as follows:
+
+- guest code reads data payload from disk (e.g. stage3 boot loader, kernel)
+- guest code checks the validity of the SCLAB
+- guest code invokes DIAG 508 subcode 1 and provides it the payload
+- QEMU handles DIAG 508 request by reading the payload and retrieving the
+  certificate store
+- QEMU DIAG 508 utilizes qcrypto libraries to perform signature-verification on
+  the payload, attempting with each cert in the store (until success or
+  exhausted)
+- QEMU DIAG 508 returns:
+
+  - success: index of cert used to verify payload
+  - failure: error code
+
+- guest code responds to this operation:
+
+  - success: retrieves cert from store via DIAG 320 using returned index
+  - failure: reports with warning (audit mode), aborts with error (secure mode)
+
+- guest code appends IIRB at the end of the IPLB
+- guest code kicks off IPL
+
+More information regarding the respective DIAGNOSE commands and IPL data
+structures are outlined within this document.
+
+
 s390 Certificate Store and Functions
 ------------------------------------
 
Signature · 1 line
2.54.0
#69 lore raw

Re: [PATCH v11 31/32] docs/specs: Add secure IPL documentation

Quoted 12 lines · Zhuoying Cai

Add documentation for secure IPL

---
 docs/specs/s390x-secure-ipl.rst | 55 +++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
docs/specs/s390x-secure-ipl.rst +0 -0
index 5fc15be99c..f4602fe19d 100644

docs/specs/s390x-secure-ipl.rst line 2

Quoted 2 lines
docs/specs/s390x-secure-ipl.rst +0 -0
@@ -1,5 +1,60 @@
 .. SPDX-License-Identifier: GPL-2.0-or-later
 

If you feel comfortable doing so, please add your Signed-off-by to this patch as well. The code in these patches are 99% of yours at this point, and if you feel that this documentation accurately reflects your work then I'd say you should take ownership of it as well.

Signature · 2 lines
Regards,
  Collin
#70 lore raw

PATCH v11 32/32 docs/system/s390x: Add secure IPL documentation

In reply to Zhuoying Cai

Add documentation for secure IPL

---
 docs/system/s390x/secure-ipl.rst | 100 +++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
docs/system/s390x/secure-ipl.rst +100 -0
index c8fb887ac0..b9123a72a0 100644
@@ -1,5 +1,22 @@
 .. SPDX-License-Identifier: GPL-2.0-or-later
 
+s390 Secure IPL
+===============
+
+Secure IPL, also known as secure boot, enables s390-ccw virtual machines to
+verify the integrity of guest kernels.
+
+For technical details of this feature, see the
+:doc:`specs document </specs/s390x-secure-ipl>`.
+
+This document explains how to use secure IPL with s390x in QEMU. It covers
+the command line options for providing certificates and enabling secure IPL,
+the different IPL modes (Normal, Audit, and Secure), and system requirements.
+
+A quickstart guide is provided to demonstrate how to generate certificates,
+sign images, and start a guest in Secure Mode.
+
+
 Secure IPL Command Line Options
 -------------------------------
 
@@ -79,3 +96,86 @@ Configuration:
 .. code-block:: shell
 
     qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on,boot-certs.0.path=/.../qemu/certs,boot-certs.1.path=/another/path/cert.pem ...
+
+
+Constraints
+-----------
+
+The following constraints apply when attempting to boot an s390x guest in secure
+mode:
+
+- z16 or "qemu" CPU model
+- certificates must be in X.509 PEM format
+- only support for SCSI scheme of virtio-blk/virtio-scsi devices
+- a boot device must be specified
+- any unsupported devices (e.g., ECKD and VFIO) or non-eligible devices (e.g.,
+  network) will cause the entire boot process terminating early with an error
+  logged to the console.
+
+
+Secure IPL Quickstart
+---------------------
+
+Build QEMU with gnutls enabled
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: shell
+
+    ./configure … --enable-gnutls
+
+Generate certificate (e.g. via certtool)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A private key is required before generating a certificate. This key must be kept
+secure and confidential.
+
+Use an RSA private key for signing.
+
+.. code-block:: shell
+
+    certtool --generate-privkey > key.pem
+
+A self-signed certificate requires the organization name. Use the ``cert.info``
+template to pre-fill values and avoid interactive prompts from certtool.
+
+.. code-block:: shell
+
+    cat > cert.info <<EOF
+    cn = "My Name"
+    expiration_days = 36500
+    cert_signing_key
+    EOF
+
+    certtool --generate-self-signed \
+             --load-privkey key.pem \
+             --template cert.info \
+             --hash=SHA256 \
+             --outfile cert.pem
+
+Sign Images (e.g. via sign-file)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- signing must be performed on a guest filesystem
+- sign-file script used in the example below is located within the kernel source
+  repo
+
+.. code-block:: shell
+
+    ./sign-file sha256 key.pem cert.pem /boot/vmlinuz-…
+    ./sign-file sha256 key.pem cert.pem /usr/lib/s390-tools/stage3.bin
+
+Run zipl with secure boot enabled
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- zipl must be performed on a guest filesystem
+
+.. code-block:: shell
+
+    zipl --secure 1 -V
+
+Command line options for starting the guest
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: shell
+
+    qemu-system-s390x -machine s390-ccw-virtio,secure-boot=on,boot-certs.0.path=cert.pem ...
Signature · 1 line
2.54.0
#72 lore raw
In reply to Zhuoying Cai

The Secure IPL configuration/state does no appear to persist across reboots.

Consider a guest provisioned with two bootable images, one is signed, one is not. The stage3.bin is properly signed.

With secure_boot=on, boot the signed image, then try to load the unsigned image using kexec.

[root@localhost ~]# kexec -ld unsigned --initrd=fake.img --reuse-cmdline
Try gzip decompression.
Try zstd decompression.
Not zstd compressed
Try LZMA decompression.
lzma_decompress_file: read on unsigned of 65536 bytes failed
[  339.375817] kexec_file: kernel: 000000000915b573 kernel_size: 0xf85130
[  339.383018] Lockdown: kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7 kexec_file_load failed: Operation not permitted

Initially kexec correctly rejects loading the unsigned image.

Reboot, then re-try loading the unsigned image.

[root@localhost ~]# kexec -ld unsigned --initrd=fake.img --reuse-cmdline
Try gzip decompression.
Try zstd decompression.
Not zstd compressed
Try LZMA decompression.
lzma_decompress_file: read on unsigned of 65536 bytes failed
[   44.654152] kexec_file: kernel: 000000009fc3b80c kernel_size: 0xf85130
[   44.774975] kexec_file: nr_segments = 4
[   44.774978] kexec_file: segment[0]: buf=0x000000009fc3b80c bufsz=0xf85130 mem=0x0 memsz=0xf86000 [   44.780416] kexec_file: segment[1]: buf=0x00000000f9e1120b bufsz=0x2dd2c52 mem=0xf86000 memsz=0x2dd3000 [   44.818676] kexec_file: segment[2]: buf=0x000000004f695d01 bufsz=0x2f60 mem=0x3d59000 memsz=0x3000 [   44.818680] kexec_file: segment[3]: buf=0x000000008a75eb84 bufsz=0x138 mem=0x3d5c000 memsz=0x1000 [   44.818682] kexec_file: kexec_file_load: type:0, start:0x0 head:0x9c2a002 flags:0x8 [root@localhost ~]#

After reboot the unsigned image loads, kexec -e can be used to bypass Secure IPL settings.

Regards,
Jared Rossi