repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/capabilities.rs | runtime/src/capabilities.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
capabilities.rs
Abstract:
File contains Capabilities mailbox command.
--*/
use crate::{mutrefbytes, Drivers};
use caliptra_common::{
capabilities::Capabilities,
mailbox_api::{CapabilitiesResp, MailboxRespHeader},
};
use caliptra_drivers::CaliptraResult;
pub struct CapabilitiesCmd;
impl CapabilitiesCmd {
#[inline(never)]
pub(crate) fn execute(drivers: &mut Drivers, resp: &mut [u8]) -> CaliptraResult<usize> {
let mut capabilities = Capabilities::default();
capabilities |= Capabilities::RT_BASE;
if drivers.ocp_lock_context.available() {
capabilities |= Capabilities::RT_OCP_LOCK;
}
let resp = mutrefbytes::<CapabilitiesResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.capabilities = capabilities.to_bytes();
Ok(core::mem::size_of::<CapabilitiesResp>())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/set_auth_manifest.rs | runtime/src/set_auth_manifest.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
set_auth_manifest.rs
Abstract:
File contains AuthManifest mailbox command.
--*/
use core::cmp::min;
use core::mem::size_of;
use crate::Drivers;
use caliptra_auth_man_types::{
AuthManifestFlags, AuthManifestImageMetadata, AuthManifestImageMetadataCollection,
AuthManifestPreamble, AUTH_MANIFEST_IMAGE_METADATA_MAX_COUNT, AUTH_MANIFEST_MARKER,
};
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_cfi_lib_git::{cfi_assert, cfi_assert_eq, cfi_assert_ge, cfi_assert_le, cfi_launder};
use caliptra_common::mailbox_api::SetAuthManifestReq;
use caliptra_drivers::{
Array4x12, Array4xN, CaliptraError, CaliptraResult, Ecc384, Ecc384PubKey, Ecc384Signature,
HashValue, Lifecycle, Lms, Mldsa87, Mldsa87PubKey, Mldsa87Result, Mldsa87Signature, Sha256,
Sha2_512_384, SocIfc,
};
use caliptra_image_types::{
FwVerificationPqcKeyType, ImageDigest384, ImageEccPubKey, ImageEccSignature, ImageLmsPublicKey,
ImageLmsSignature, ImagePreamble, SHA192_DIGEST_WORD_SIZE, SHA384_DIGEST_BYTE_SIZE,
};
use memoffset::offset_of;
use zerocopy::{FromBytes, IntoBytes};
use zeroize::Zeroize;
pub struct SetAuthManifestCmd;
impl SetAuthManifestCmd {
fn sha384_digest(
sha2: &mut Sha2_512_384,
buf: &[u8],
offset: u32,
len: u32,
) -> CaliptraResult<ImageDigest384> {
let err = CaliptraError::IMAGE_VERIFIER_ERR_DIGEST_OUT_OF_BOUNDS;
let data = buf
.get(offset as usize..)
.ok_or(err)?
.get(..len as usize)
.ok_or(err)?;
Ok(sha2.sha384_digest(data)?.0)
}
fn offset_data(buf: &[u8], offset: u32, len: u32) -> CaliptraResult<&[u8]> {
let err = CaliptraError::IMAGE_VERIFIER_ERR_DIGEST_OUT_OF_BOUNDS;
buf.get(offset as usize..)
.ok_or(err)?
.get(..len as usize)
.ok_or(err)
}
fn ecc384_verify(
ecc384: &mut Ecc384,
digest: &ImageDigest384,
pub_key: &ImageEccPubKey,
sig: &ImageEccSignature,
) -> CaliptraResult<Array4xN<12, 48>> {
let pub_key = Ecc384PubKey {
x: pub_key.x.into(),
y: pub_key.y.into(),
};
let digest: Array4x12 = digest.into();
let sig = Ecc384Signature {
r: sig.r.into(),
s: sig.s.into(),
};
ecc384.verify_r(&pub_key, &digest, &sig)
}
fn lms_verify(
sha256: &mut Sha256,
digest: &ImageDigest384,
pub_key: &ImageLmsPublicKey,
sig: &ImageLmsSignature,
) -> CaliptraResult<HashValue<SHA192_DIGEST_WORD_SIZE>> {
let mut message = [0u8; SHA384_DIGEST_BYTE_SIZE];
for i in 0..digest.len() {
message[i * 4..][..4].copy_from_slice(&digest[i].to_be_bytes());
}
Lms::default().verify_lms_signature_cfi(sha256, &message, pub_key, sig)
}
fn verify_vendor_signed_data(
auth_manifest_preamble: &AuthManifestPreamble,
fw_preamble: &ImagePreamble,
sha2: &mut Sha2_512_384,
ecc384: &mut Ecc384,
sha256: &mut Sha256,
mldsa: &mut Mldsa87,
pqc_key_type: FwVerificationPqcKeyType,
) -> CaliptraResult<()> {
let range = AuthManifestPreamble::vendor_signed_data_range();
let digest_vendor = Self::sha384_digest(
sha2,
auth_manifest_preamble.as_bytes(),
range.start,
range.len() as u32,
)?;
// Verify the vendor ECC signature.
let verify_r = Self::ecc384_verify(
ecc384,
&digest_vendor,
&fw_preamble.vendor_ecc_active_pub_key,
&auth_manifest_preamble.vendor_pub_keys_signatures.ecc_sig,
)
.map_err(|_| CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID)?;
if cfi_launder(verify_r)
!= caliptra_drivers::Array4xN(
auth_manifest_preamble.vendor_pub_keys_signatures.ecc_sig.r,
)
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_12_words(
&verify_r.0,
&auth_manifest_preamble.vendor_pub_keys_signatures.ecc_sig.r,
);
}
// Verify vendor PQC signature.
if pqc_key_type == FwVerificationPqcKeyType::LMS {
let (vendor_fw_lms_key, _) = ImageLmsPublicKey::ref_from_prefix(
fw_preamble.vendor_pqc_active_pub_key.0.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_LMS_VENDOR_PUB_KEY_INVALID,
))?;
let (lms_sig, _) = ImageLmsSignature::ref_from_prefix(
auth_manifest_preamble
.vendor_pub_keys_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID,
))?;
let candidate_key =
Self::lms_verify(sha256, &digest_vendor, vendor_fw_lms_key, lms_sig).map_err(
|_| CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID,
)?;
let pub_key_digest = HashValue::from(vendor_fw_lms_key.digest);
if candidate_key != pub_key_digest {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_6_words(&candidate_key.0, &pub_key_digest.0);
}
} else {
let vendor_data = Self::offset_data(
auth_manifest_preamble.as_bytes(),
range.start,
range.len() as u32,
)?;
let (vendor_fw_mldsa_key, _) =
Mldsa87PubKey::ref_from_prefix(fw_preamble.vendor_pqc_active_pub_key.0.as_bytes())
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_PUB_KEY_READ_FAILED,
))?;
let (mldsa_sig, _) = Mldsa87Signature::ref_from_prefix(
auth_manifest_preamble
.vendor_pub_keys_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_SIG_READ_FAILED,
))?;
let result = mldsa.verify_var(vendor_fw_mldsa_key, vendor_data, mldsa_sig)?;
if cfi_launder(result) != Mldsa87Result::Success {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_SIG_INVALID)?;
}
}
Ok(())
}
fn verify_owner_pub_keys(
auth_manifest_preamble: &AuthManifestPreamble,
fw_preamble: &ImagePreamble,
sha2: &mut Sha2_512_384,
ecc384: &mut Ecc384,
sha256: &mut Sha256,
mldsa: &mut Mldsa87,
pqc_key_type: FwVerificationPqcKeyType,
) -> CaliptraResult<()> {
let range = AuthManifestPreamble::owner_pub_keys_range();
let digest_owner = Self::sha384_digest(
sha2,
auth_manifest_preamble.as_bytes(),
range.start,
range.len() as u32,
)?;
// Verify the owner ECC signature.
let owner_fw_ecc_key = &fw_preamble.owner_pub_keys.ecc_pub_key;
let verify_r = Self::ecc384_verify(
ecc384,
&digest_owner,
owner_fw_ecc_key,
&auth_manifest_preamble.owner_pub_keys_signatures.ecc_sig,
)
.map_err(|_| CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID)?;
if cfi_launder(verify_r)
!= caliptra_drivers::Array4xN(
auth_manifest_preamble.owner_pub_keys_signatures.ecc_sig.r,
)
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_12_words(
&verify_r.0,
&auth_manifest_preamble.owner_pub_keys_signatures.ecc_sig.r,
);
}
// Verify owner LMS signature.
if pqc_key_type == FwVerificationPqcKeyType::LMS {
let (owner_fw_lms_key, _) = ImageLmsPublicKey::ref_from_prefix(
fw_preamble.owner_pub_keys.pqc_pub_key.0.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_LMS_OWNER_PUB_KEY_INVALID,
))?;
let (lms_sig, _) = ImageLmsSignature::ref_from_prefix(
auth_manifest_preamble
.owner_pub_keys_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID,
))?;
let candidate_key = Self::lms_verify(sha256, &digest_owner, owner_fw_lms_key, lms_sig)
.map_err(|_| CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID)?;
let pub_key_digest = HashValue::from(owner_fw_lms_key.digest);
if candidate_key != pub_key_digest {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_6_words(&candidate_key.0, &pub_key_digest.0);
}
} else {
let owner_data = Self::offset_data(
auth_manifest_preamble.as_bytes(),
range.start,
range.len() as u32,
)?;
let (owner_fw_mldsa_key, _) =
Mldsa87PubKey::ref_from_prefix(fw_preamble.owner_pub_keys.pqc_pub_key.0.as_bytes())
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_PUB_KEY_READ_FAILED,
))?;
let (mldsa_sig, _) = Mldsa87Signature::ref_from_prefix(
auth_manifest_preamble
.owner_pub_keys_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_SIG_READ_FAILED,
))?;
let result = mldsa.verify_var(owner_fw_mldsa_key, owner_data, mldsa_sig)?;
if cfi_launder(result) != Mldsa87Result::Success {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_SIG_INVALID)?;
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn verify_vendor_image_metadata_col(
auth_manifest_preamble: &AuthManifestPreamble,
image_metadata_col_digest: &ImageDigest384,
ecc384: &mut Ecc384,
sha256: &mut Sha256,
mldsa: &mut Mldsa87,
_sha2: &mut Sha2_512_384,
pqc_key_type: FwVerificationPqcKeyType,
metadata_col: &[u8],
) -> CaliptraResult<()> {
let flags = AuthManifestFlags::from(auth_manifest_preamble.flags);
if !flags.contains(AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED) {
return Ok(());
}
// Verify the vendor ECC signature over the image metadata collection.
let verify_r = Self::ecc384_verify(
ecc384,
image_metadata_col_digest,
&auth_manifest_preamble.vendor_pub_keys.ecc_pub_key,
&auth_manifest_preamble
.vendor_image_metdata_signatures
.ecc_sig,
)
.map_err(|_| CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID)?;
if cfi_launder(verify_r)
!= caliptra_drivers::Array4xN(
auth_manifest_preamble
.vendor_image_metdata_signatures
.ecc_sig
.r,
)
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_12_words(
&verify_r.0,
&auth_manifest_preamble
.vendor_image_metdata_signatures
.ecc_sig
.r,
);
}
// Verify vendor PQC signature over the image metadata collection.
if pqc_key_type == FwVerificationPqcKeyType::LMS {
let (lms_pub_key, _) = ImageLmsPublicKey::ref_from_prefix(
auth_manifest_preamble
.vendor_pub_keys
.pqc_pub_key
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_LMS_VENDOR_PUB_KEY_INVALID,
))?;
let (lms_sig, _) = ImageLmsSignature::ref_from_prefix(
auth_manifest_preamble
.vendor_image_metdata_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID,
))?;
let candidate_key =
Self::lms_verify(sha256, image_metadata_col_digest, lms_pub_key, lms_sig).map_err(
|_| CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID,
)?;
let pub_key_digest = HashValue::from(lms_pub_key.digest);
if candidate_key != pub_key_digest {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_6_words(&candidate_key.0, &pub_key_digest.0);
}
} else {
let metadata_col_data = Self::offset_data(metadata_col, 0, metadata_col.len() as u32)?;
let (mldsa_pub_key, _) = Mldsa87PubKey::ref_from_prefix(
auth_manifest_preamble
.vendor_pub_keys
.pqc_pub_key
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_PUB_KEY_READ_FAILED,
))?;
let (mldsa_sig, _) = Mldsa87Signature::ref_from_prefix(
auth_manifest_preamble
.vendor_image_metdata_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_SIG_READ_FAILED,
))?;
let result = mldsa.verify_var(mldsa_pub_key, metadata_col_data, mldsa_sig)?;
if cfi_launder(result) != Mldsa87Result::Success {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_VENDOR_SIG_INVALID)?;
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn verify_owner_image_metadata_col(
auth_manifest_preamble: &AuthManifestPreamble,
image_metadata_col_digest: &ImageDigest384,
ecc384: &mut Ecc384,
sha256: &mut Sha256,
mldsa: &mut Mldsa87,
_sha2: &mut Sha2_512_384,
pqc_key_type: FwVerificationPqcKeyType,
metadata_col: &[u8],
) -> CaliptraResult<()> {
// Verify the owner ECC signature.
let verify_r = Self::ecc384_verify(
ecc384,
image_metadata_col_digest,
&auth_manifest_preamble.owner_pub_keys.ecc_pub_key,
&auth_manifest_preamble
.owner_image_metdata_signatures
.ecc_sig,
)
.map_err(|_| CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID)?;
if cfi_launder(verify_r)
!= caliptra_drivers::Array4xN(
auth_manifest_preamble
.owner_image_metdata_signatures
.ecc_sig
.r,
)
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_12_words(
&verify_r.0,
&auth_manifest_preamble
.owner_image_metdata_signatures
.ecc_sig
.r,
);
}
// Verify owner PQC signature.
if pqc_key_type == FwVerificationPqcKeyType::LMS {
let (lms_pub_key, _) = ImageLmsPublicKey::ref_from_prefix(
auth_manifest_preamble
.owner_pub_keys
.pqc_pub_key
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_LMS_OWNER_PUB_KEY_INVALID,
))?;
let (lms_sig, _) = ImageLmsSignature::ref_from_prefix(
auth_manifest_preamble
.owner_image_metdata_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID,
))?;
let candidate_key =
Self::lms_verify(sha256, image_metadata_col_digest, lms_pub_key, lms_sig).map_err(
|_| CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID,
)?;
let pub_key_digest = HashValue::from(lms_pub_key.digest);
if candidate_key != pub_key_digest {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID)?;
} else {
caliptra_cfi_lib_git::cfi_assert_eq_6_words(&candidate_key.0, &pub_key_digest.0);
}
} else {
let metadata_col_data = Self::offset_data(metadata_col, 0, metadata_col.len() as u32)?;
let (mldsa_pub_key, _) = Mldsa87PubKey::ref_from_prefix(
auth_manifest_preamble
.owner_pub_keys
.pqc_pub_key
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_PUB_KEY_READ_FAILED,
))?;
let (mldsa_sig, _) = Mldsa87Signature::ref_from_prefix(
auth_manifest_preamble
.owner_image_metdata_signatures
.pqc_sig
.0
.as_bytes(),
)
.or(Err(
CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_SIG_READ_FAILED,
))?;
let result = mldsa.verify_var(mldsa_pub_key, metadata_col_data, mldsa_sig)?;
if cfi_launder(result) != Mldsa87Result::Success {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_MLDSA_OWNER_SIG_INVALID)?;
}
}
Ok(())
}
pub fn verify_svn(soc_ifc: &SocIfc, svn: u32) -> CaliptraResult<()> {
let svn_check_required =
if cfi_launder(soc_ifc.lifecycle() as u32) == Lifecycle::Unprovisioned as u32 {
cfi_assert_eq(soc_ifc.lifecycle() as u32, Lifecycle::Unprovisioned as u32);
false
} else if cfi_launder(soc_ifc.fuse_bank().anti_rollback_disable()) {
cfi_assert!(soc_ifc.fuse_bank().anti_rollback_disable());
false
} else {
true
};
if svn_check_required {
if (cfi_launder(svn) > 128)
|| (cfi_launder(svn) > soc_ifc.fuse_bank().max_soc_manifest_fuse_svn())
{
Err(CaliptraError::IMAGE_VERIFIER_ERR_FIRMWARE_SVN_GREATER_THAN_MAX_SUPPORTED)?;
} else {
cfi_assert_le(svn, 128);
cfi_assert_le(svn, soc_ifc.fuse_bank().max_soc_manifest_fuse_svn());
}
if cfi_launder(svn) < soc_ifc.fuse_bank().soc_manifest_fuse_svn() {
Err(CaliptraError::IMAGE_VERIFIER_ERR_FIRMWARE_SVN_LESS_THAN_FUSE)?;
} else {
cfi_assert_ge(svn, soc_ifc.fuse_bank().soc_manifest_fuse_svn());
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn process_image_metadata_col(
cmd_buf: &[u8],
auth_manifest_preamble: &AuthManifestPreamble,
metadata_persistent: &mut AuthManifestImageMetadataCollection,
sha2: &mut Sha2_512_384,
ecc384: &mut Ecc384,
sha256: &mut Sha256,
mldsa: &mut Mldsa87,
pqc_key_type: FwVerificationPqcKeyType,
verify_only: bool,
) -> CaliptraResult<()> {
if cmd_buf.len() < size_of::<u32>() {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_SIZE)?;
}
let metadata_size = min(
cmd_buf.len(),
size_of::<AuthManifestImageMetadataCollection>(),
);
// Resize the buffer to the metadata size.
let buf = cmd_buf
.get(..metadata_size)
.ok_or(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_SIZE)?;
// Typecast the mailbox buffer to the image metadata collection.
let metadata_mailbox =
unsafe { &mut *(buf.as_ptr() as *mut AuthManifestImageMetadataCollection) };
if metadata_mailbox.entry_count == 0
|| metadata_mailbox.entry_count > AUTH_MANIFEST_IMAGE_METADATA_MAX_COUNT as u32
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_ENTRY_COUNT)?;
}
// Check if the buffer contains the entry count and all the image metadata entries specified by the entry count.
if buf.len()
< (size_of::<u32>()
+ metadata_mailbox.entry_count as usize * size_of::<AuthManifestImageMetadata>())
{
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_SIZE)?;
}
// Calculate the digest of the image metadata collection.
let digest_metadata_col = Self::sha384_digest(sha2, buf, 0, metadata_size as u32)?;
Self::verify_vendor_image_metadata_col(
auth_manifest_preamble,
&digest_metadata_col,
ecc384,
sha256,
mldsa,
sha2,
pqc_key_type,
buf,
)?;
Self::verify_owner_image_metadata_col(
auth_manifest_preamble,
&digest_metadata_col,
ecc384,
sha256,
mldsa,
sha2,
pqc_key_type,
buf,
)?;
// Sort the image metadata list by firmware ID in place. Also check for duplicate firmware IDs. let slice =
let slice =
&mut metadata_mailbox.image_metadata_list[..metadata_mailbox.entry_count as usize];
Self::sort_and_check_duplicate_fwid(slice)?;
if !verify_only {
// Clear the previous image metadata collection.
metadata_persistent.zeroize();
// Copy the image metadata collection to the persistent data.
metadata_persistent.as_mut_bytes()[..buf.len()].copy_from_slice(buf);
}
Ok(())
}
fn sort_and_check_duplicate_fwid(
slice: &mut [AuthManifestImageMetadata],
) -> CaliptraResult<()> {
for i in 1..slice.len() {
let mut j = i;
while j > 0 {
if j >= slice.len() {
break;
}
match slice[j - 1].fw_id.cmp(&slice[j].fw_id) {
core::cmp::Ordering::Greater => {
slice.swap(j - 1, j);
j -= 1;
}
core::cmp::Ordering::Equal => {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_DUPLICATE_FIRMWARE_ID)?;
}
_ => {
break;
}
}
}
}
Ok(())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn execute(
drivers: &mut Drivers,
cmd_args: &[u8],
verify_only: bool,
) -> CaliptraResult<usize> {
// Validate cmd length
let manifest_size: usize = {
let err = CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS;
let offset = offset_of!(SetAuthManifestReq, manifest_size);
u32::from_le_bytes(
cmd_args
.get(offset..offset + 4)
.ok_or(err)?
.try_into()
.map_err(|_| err)?,
)
.try_into()
.unwrap()
};
if manifest_size > SetAuthManifestReq::MAX_MAN_SIZE {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let manifest_buf = {
let offset = offset_of!(SetAuthManifestReq, manifest);
cmd_args
.get(offset..offset + manifest_size)
.ok_or(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?
};
Self::set_auth_manifest(drivers, manifest_buf, verify_only)?;
Ok(0)
}
pub(crate) fn set_auth_manifest(
drivers: &mut Drivers,
manifest_buf: &[u8],
verify_only: bool,
) -> CaliptraResult<()> {
let preamble_size = size_of::<AuthManifestPreamble>();
let auth_manifest_preamble = {
let err = CaliptraError::RUNTIME_AUTH_MANIFEST_PREAMBLE_SIZE_LT_MIN;
let bytes = manifest_buf.get(..preamble_size).ok_or(err)?;
AuthManifestPreamble::ref_from_bytes(bytes).map_err(|_| err)?
};
// Check if the preamble has the required marker.
if auth_manifest_preamble.marker != AUTH_MANIFEST_MARKER {
Err(CaliptraError::RUNTIME_INVALID_AUTH_MANIFEST_MARKER)?;
}
// Check if the manifest size is valid.
if auth_manifest_preamble.size as usize != size_of::<AuthManifestPreamble>() {
Err(CaliptraError::RUNTIME_AUTH_MANIFEST_PREAMBLE_SIZE_MISMATCH)?;
}
// Verify SVN
Self::verify_svn(&drivers.soc_ifc, auth_manifest_preamble.svn)?;
let pqc_key_type =
FwVerificationPqcKeyType::from_u8(drivers.soc_ifc.fuse_bank().pqc_key_type() as u8)
.ok_or(CaliptraError::IMAGE_VERIFIER_ERR_INVALID_PQC_KEY_TYPE_IN_FUSE)?;
let persistent_data = drivers.persistent_data.get_mut();
// Verify the vendor signed data (vendor public keys + flags).
Self::verify_vendor_signed_data(
auth_manifest_preamble,
&persistent_data.rom.manifest1.preamble,
&mut drivers.sha2_512_384,
&mut drivers.ecc384,
&mut drivers.sha256,
&mut drivers.mldsa87,
pqc_key_type,
)?;
// Verify the owner public keys.
Self::verify_owner_pub_keys(
auth_manifest_preamble,
&persistent_data.rom.manifest1.preamble,
&mut drivers.sha2_512_384,
&mut drivers.ecc384,
&mut drivers.sha256,
&mut drivers.mldsa87,
pqc_key_type,
)?;
Self::process_image_metadata_col(
manifest_buf
.get(preamble_size..)
.ok_or(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_SIZE)?,
auth_manifest_preamble,
&mut persistent_data.fw.auth_manifest_image_metadata_col,
&mut drivers.sha2_512_384,
&mut drivers.ecc384,
&mut drivers.sha256,
&mut drivers.mldsa87,
pqc_key_type,
verify_only,
)?;
if !verify_only {
persistent_data.fw.auth_manifest_digest =
drivers.sha2_512_384.sha384_digest(manifest_buf)?.0;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn is_sorted(slice: &[AuthManifestImageMetadata]) -> bool {
for i in 0..slice.len() - 1 {
if slice[i].fw_id > slice[i + 1].fw_id {
return false;
}
}
true
}
#[test]
fn test_sort_and_duplicate_empty() {
let resp = SetAuthManifestCmd::sort_and_check_duplicate_fwid(&mut []);
assert!(resp.is_ok());
}
#[test]
fn test_sort_and_duplicate_sort() {
let mut list = [
AuthManifestImageMetadata {
fw_id: 5,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
AuthManifestImageMetadata {
fw_id: 127,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
AuthManifestImageMetadata {
fw_id: 48,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
];
let resp = SetAuthManifestCmd::sort_and_check_duplicate_fwid(&mut list);
assert!(resp.is_ok());
assert!(is_sorted(&list));
}
#[test]
fn test_sort_and_duplicate_dupe() {
let mut list = [
AuthManifestImageMetadata {
fw_id: 127,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
AuthManifestImageMetadata {
fw_id: 5,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
AuthManifestImageMetadata {
fw_id: 127,
flags: 0,
digest: [0u8; 48],
..Default::default()
},
];
let resp = SetAuthManifestCmd::sort_and_check_duplicate_fwid(&mut list);
assert_eq!(
resp.unwrap_err(),
CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_DUPLICATE_FIRMWARE_ID
);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/fe_programming.rs | runtime/src/fe_programming.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
fe_programming.rs
Abstract:
File contains FE_PROG mailbox command.
--*/
use crate::Drivers;
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_common::mailbox_api::FeProgReq;
use caliptra_common::uds_fe_programming::UdsFeProgrammingFlow;
use caliptra_drivers::{CaliptraError, CaliptraResult, Lifecycle};
use zerocopy::FromBytes;
pub struct FeProgrammingCmd;
impl FeProgrammingCmd {
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn execute(drivers: &mut Drivers, cmd_bytes: &[u8]) -> CaliptraResult<usize> {
let cmd = FeProgReq::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::RUNTIME_INSUFFICIENT_MEMORY)?;
if drivers.soc_ifc.lifecycle() != Lifecycle::Production {
Err(CaliptraError::RUNTIME_FE_PROG_ILLEGAL_LIFECYCLE_STATE)?;
}
let fe_programmer = UdsFeProgrammingFlow::Fe {
partition: cmd.partition,
};
// Call the common FE programming function
fe_programmer.program(&mut drivers.soc_ifc, &mut drivers.trng, &drivers.dma)?;
Ok(0)
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/cryptographic_mailbox.rs | runtime/src/cryptographic_mailbox.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
cryptographic_mailbox.rs
Abstract:
File contains exports for the Cryptographic Mailbox API commands.
--*/
use crate::{mutrefbytes, Drivers};
use arrayvec::ArrayVec;
use bitfield::bitfield;
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_common::{
crypto::{Crypto, EncryptedCmk, UnencryptedCmk, UNENCRYPTED_CMK_SIZE_BYTES},
hmac_cm::hmac,
keyids::{KEY_ID_STABLE_IDEV, KEY_ID_STABLE_LDEV},
mailbox_api::{
CmAesDecryptInitReq, CmAesDecryptUpdateReq, CmAesEncryptInitReq, CmAesEncryptInitResp,
CmAesEncryptUpdateReq, CmAesGcmDecryptFinalReq, CmAesGcmDecryptFinalResp,
CmAesGcmDecryptInitReq, CmAesGcmDecryptInitResp, CmAesGcmDecryptUpdateReq,
CmAesGcmDecryptUpdateResp, CmAesGcmEncryptFinalReq, CmAesGcmEncryptFinalResp,
CmAesGcmEncryptInitReq, CmAesGcmEncryptInitResp, CmAesGcmEncryptUpdateReq,
CmAesGcmEncryptUpdateResp, CmAesGcmSpdmDecryptInitReq, CmAesGcmSpdmDecryptInitResp,
CmAesGcmSpdmEncryptInitReq, CmAesGcmSpdmEncryptInitResp, CmAesMode, CmAesResp, CmDeleteReq,
CmDeriveStableKeyReq, CmDeriveStableKeyResp, CmEcdhFinishReq, CmEcdhFinishResp,
CmEcdhGenerateReq, CmEcdhGenerateResp, CmEcdsaPublicKeyReq, CmEcdsaPublicKeyResp,
CmEcdsaSignReq, CmEcdsaSignResp, CmEcdsaVerifyReq, CmHashAlgorithm, CmHkdfExpandReq,
CmHkdfExpandResp, CmHkdfExtractReq, CmHkdfExtractResp, CmHmacKdfCounterReq,
CmHmacKdfCounterResp, CmImportReq, CmImportResp, CmKeyUsage, CmMldsaPublicKeyReq,
CmMldsaPublicKeyResp, CmMldsaSignReq, CmMldsaSignResp, CmMldsaVerifyReq,
CmRandomGenerateReq, CmRandomGenerateResp, CmRandomStirReq, CmShaFinalResp, CmShaInitReq,
CmShaInitResp, CmShaUpdateReq, CmStableKeyType, CmStatusResp, Cmk as MailboxCmk,
MailboxRespHeader, MailboxRespHeaderVarSize, ResponseVarSize,
CMB_AES_GCM_ENCRYPTED_CONTEXT_SIZE, CMB_ECDH_CONTEXT_SIZE, CMB_ECDH_ENCRYPTED_CONTEXT_SIZE,
CMB_SHA_CONTEXT_SIZE, CMK_MAX_KEY_SIZE_BITS, CMK_SIZE_BYTES, CM_STABLE_KEY_INFO_SIZE_BYTES,
MAX_CMB_DATA_SIZE,
},
};
use caliptra_drivers::{
cmac_kdf, hkdf_expand, hkdf_extract, hmac_kdf,
sha2_512_384::{Sha2DigestOpTrait, SHA512_BLOCK_BYTE_SIZE, SHA512_HASH_SIZE},
Aes, AesContext, AesGcmContext, AesGcmIv, AesKey, AesOperation, Array4x12, Array4x16,
CaliptraResult, Ecc384PrivKeyIn, Ecc384PrivKeyOut, Ecc384PubKey, Ecc384Result, Ecc384Seed,
Ecc384Signature, HmacMode, KeyReadArgs, LEArray4x1157, LEArray4x3, LEArray4x4, LEArray4x8,
Mldsa87Result, Mldsa87Seed, PersistentDataAccessor, Sha2_512_384, Trng, AES_BLOCK_SIZE_BYTES,
AES_CONTEXT_SIZE_BYTES, AES_GCM_CONTEXT_SIZE_BYTES, MAX_SEED_WORDS,
};
use caliptra_error::CaliptraError;
use caliptra_image_types::{
ECC384_SCALAR_BYTE_SIZE, SHA384_DIGEST_BYTE_SIZE, SHA512_DIGEST_BYTE_SIZE,
};
use zerocopy::{transmute, FromBytes, Immutable, IntoBytes, KnownLayout};
pub const GCM_MAX_KEY_USES: u64 = (1 << 32) - 1;
pub const KEY_USAGE_MAX: usize = 256;
pub const MLDSA_SEED_SIZE: usize = 32;
// We have 24 bits for the key ID.
const MAX_KEY_ID: u32 = 0xffffff;
bitfield! {
#[derive(Clone, Copy)]
pub struct SpdmFlags(u32);
pub version, set_image_version: 7, 0;
pub counter_big_endian, set_counter_big_endian: 8, 8;
}
/// Holds data for the cryptographic mailbox system.
#[derive(Default)]
pub struct CmStorage {
initialized: bool,
// Usage counters for individual GCM keys.
counters: ArrayVec<KeyUsageInfo, KEY_USAGE_MAX>,
// 1-up counter for KEK GCM IV
kek_next_iv: u128,
// KEK split into two key shares
kek: (LEArray4x8, LEArray4x8),
// 1-up counter for context GCM IV
context_next_iv: u128,
// key for encrypting contexts
context_key: (LEArray4x8, LEArray4x8),
}
impl CmStorage {
pub fn new() -> Self {
Self {
kek: (LEArray4x8::default(), LEArray4x8::default()),
context_key: (LEArray4x8::default(), LEArray4x8::default()),
..Default::default()
}
}
/// Initialize the cryptographic mailbox storage key and IV.
/// This is done after the TRNG is initialized and CFI is configured.
pub fn init(&mut self, pdata: &PersistentDataAccessor, trng: &mut Trng) -> CaliptraResult<()> {
let kek_random_iv = trng.generate4()?;
// we mask off the top bit so that we always have at least 2^95 usages left.
self.context_next_iv = (((kek_random_iv.0 & 0x7fff_ffff) as u128) << 64)
| ((kek_random_iv.1 as u128) << 32)
| (kek_random_iv.2 as u128);
self.kek = Crypto::get_cmb_aes_key(pdata.get());
let context_key_share0: [u32; 8] = trng.generate()?.0[..8].try_into().unwrap();
let context_key_share1: [u32; 8] = trng.generate()?.0[..8].try_into().unwrap();
// we mask off the top bit so that we always have at least 2^95 usages left.
let context_random_iv = trng.generate4()?;
self.context_next_iv = (((context_random_iv.0 & 0x7fff_ffff) as u128) << 64)
| ((context_random_iv.1 as u128) << 32)
| (context_random_iv.2 as u128);
self.context_key = (
transmute!(context_key_share0),
transmute!(context_key_share1),
);
self.initialized = true;
Ok(())
}
fn increment_counter(&mut self, cmk: &UnencryptedCmk) -> CaliptraResult<u64> {
match self
.counters
.binary_search_by_key(&cmk.key_id(), |k| k.key_id)
{
Ok(idx) => Ok(self.counters[idx].increment()),
Err(_) => Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS),
}
}
/// Inserts a new counter (with 0 usage) and returns the new key id.
pub fn add_counter(&mut self) -> CaliptraResult<[u8; 3]> {
if self.counters.is_full() {
return Err(CaliptraError::RUNTIME_CMB_KEY_USAGE_STORAGE_FULL);
}
let mut key_id =
(self.counters.last().map(|last| last.key_id).unwrap_or(0) + 1) % MAX_KEY_ID;
// normally we could just append to the end of the list, but if keys have been deleted,
// we could potentially wraparound the 24-bit key id space, so we have to check
loop {
match self.counters.binary_search_by_key(&key_id, |k| k.key_id) {
Ok(_) => {
// key_id already exists, increment and try again
// this only happens where there has been wraparound due to many keys imported and deleted
key_id = (key_id + 1) % MAX_KEY_ID;
continue;
}
Err(index) => {
let key_usage_info = KeyUsageInfo { key_id, counter: 0 };
self.counters.insert(index, key_usage_info);
return Ok(key_id.to_le_bytes()[0..3].try_into().unwrap());
}
}
}
}
/// Deletes the counter for the given key id, if it exists.
pub fn delete_counter(&mut self, key_id: u32) -> CaliptraResult<()> {
match self.counters.binary_search_by_key(&key_id, |k| k.key_id) {
Ok(idx) => {
self.counters.remove(idx);
Ok(())
}
Err(_) => Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS),
}
}
/// Deletes all counters.
pub fn clear_counters(&mut self) {
self.counters.clear();
}
fn encrypt_cmk(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
unencrypted_cmk: &UnencryptedCmk,
) -> CaliptraResult<EncryptedCmk> {
let kek_iv: [u32; 4] = transmute!(self.kek_next_iv);
let kek_iv: [u32; 3] = kek_iv[..3].try_into().unwrap();
self.kek_next_iv += 1;
Crypto::encrypt_cmk(aes, trng, unencrypted_cmk, kek_iv.into(), self.kek)
}
fn decrypt_cmk(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
encrypted_cmk: &EncryptedCmk,
) -> CaliptraResult<UnencryptedCmk> {
Crypto::decrypt_cmk(aes, trng, self.kek, encrypted_cmk)
}
fn encrypt_aes_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
unencrypted_context: &AesContext,
) -> CaliptraResult<EncryptedAesContext> {
let context_iv: [u32; 4] = transmute!(self.context_next_iv);
let context_iv: [u32; 3] = context_iv[..3].try_into().unwrap();
let context_iv: LEArray4x3 = context_iv.into();
self.context_next_iv += 1;
let mut ciphertext = [0u8; AES_CONTEXT_SIZE_BYTES];
// Encrypt the context using the context key
let (iv, tag) = aes.aes_256_gcm_encrypt(
trng,
AesGcmIv::Array(&context_iv),
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
unencrypted_context.as_bytes(),
&mut ciphertext[..],
16,
)?;
Ok(EncryptedAesContext {
iv,
tag,
ciphertext,
})
}
fn decrypt_aes_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
encrypted_context: &EncryptedAesContext,
) -> CaliptraResult<AesContext> {
let ciphertext = &encrypted_context.ciphertext;
let mut plaintext = [0u8; AES_CONTEXT_SIZE_BYTES];
aes.aes_256_gcm_decrypt(
trng,
&encrypted_context.iv,
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
ciphertext,
&mut plaintext,
&encrypted_context.tag,
)?;
Ok(transmute!(plaintext))
}
fn encrypt_aes_gcm_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
unencrypted_context: &AesGcmContext,
) -> CaliptraResult<EncryptedAesGcmContext> {
let context_iv: [u32; 4] = transmute!(self.context_next_iv);
let context_iv: [u32; 3] = context_iv[..3].try_into().unwrap();
let context_iv: LEArray4x3 = context_iv.into();
self.context_next_iv += 1;
let mut ciphertext = [0u8; AES_GCM_CONTEXT_SIZE_BYTES];
// Encrypt the context using the context key
let (iv, tag) = aes.aes_256_gcm_encrypt(
trng,
AesGcmIv::Array(&context_iv),
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
unencrypted_context.as_bytes(),
&mut ciphertext[..],
16,
)?;
Ok(EncryptedAesGcmContext {
iv,
tag,
ciphertext,
})
}
fn decrypt_aes_gcm_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
encrypted_context: &EncryptedAesGcmContext,
) -> CaliptraResult<AesGcmContext> {
let ciphertext = &encrypted_context.ciphertext;
let mut plaintext = [0u8; AES_GCM_CONTEXT_SIZE_BYTES];
aes.aes_256_gcm_decrypt(
trng,
&encrypted_context.iv,
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
ciphertext,
&mut plaintext,
&encrypted_context.tag,
)?;
Ok(transmute!(plaintext))
}
fn encrypt_ecdh_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
unencrypted_context: &[u8; CMB_ECDH_CONTEXT_SIZE],
) -> CaliptraResult<EncryptedEcdhContext> {
let context_iv: [u32; 4] = transmute!(self.context_next_iv);
let context_iv: [u32; 3] = context_iv[..3].try_into().unwrap();
let context_iv: LEArray4x3 = context_iv.into();
self.context_next_iv += 1;
let mut ciphertext = [0u8; CMB_ECDH_CONTEXT_SIZE];
// Encrypt the context using the context key
let (iv, tag) = aes.aes_256_gcm_encrypt(
trng,
AesGcmIv::Array(&context_iv),
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
unencrypted_context,
&mut ciphertext[..],
16,
)?;
Ok(EncryptedEcdhContext {
iv,
tag,
ciphertext,
})
}
fn decrypt_ecdh_context(
&mut self,
aes: &mut Aes,
trng: &mut Trng,
encrypted_context: &EncryptedEcdhContext,
) -> CaliptraResult<[u8; CMB_ECDH_CONTEXT_SIZE]> {
let ciphertext = &encrypted_context.ciphertext;
let mut plaintext = [0u8; CMB_ECDH_CONTEXT_SIZE];
aes.aes_256_gcm_decrypt(
trng,
&encrypted_context.iv,
AesKey::Split(&self.context_key.0, &self.context_key.1),
&[],
ciphertext,
&mut plaintext,
&encrypted_context.tag,
)?;
Ok(plaintext)
}
}
#[derive(Default)]
struct KeyUsageInfo {
key_id: u32,
#[allow(unused)]
counter: u64,
}
impl KeyUsageInfo {
fn increment(&mut self) -> u64 {
self.counter += 1;
self.counter
}
}
#[repr(C)]
#[derive(Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
pub struct ShaContext {
pub length: u32,
pub hash_algorithm: u32,
pub input_buffer: [u8; SHA512_BLOCK_BYTE_SIZE],
pub intermediate_hash: [u8; SHA512_HASH_SIZE],
}
impl Default for ShaContext {
fn default() -> Self {
ShaContext {
input_buffer: [0u8; SHA512_BLOCK_BYTE_SIZE],
intermediate_hash: [0u8; SHA512_HASH_SIZE],
length: 0,
hash_algorithm: 0,
}
}
}
#[repr(C)]
#[derive(Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
pub struct EncryptedAesContext {
pub iv: LEArray4x3,
pub tag: LEArray4x4,
pub ciphertext: [u8; AES_CONTEXT_SIZE_BYTES],
}
#[repr(C)]
#[derive(Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
pub struct EncryptedAesGcmContext {
pub iv: LEArray4x3,
pub tag: LEArray4x4,
pub ciphertext: [u8; AES_GCM_CONTEXT_SIZE_BYTES],
}
#[repr(C)]
#[derive(Clone, FromBytes, Immutable, IntoBytes, KnownLayout)]
struct EncryptedEcdhContext {
pub iv: LEArray4x3,
pub tag: LEArray4x4,
pub ciphertext: [u8; CMB_ECDH_CONTEXT_SIZE],
}
const _: () = assert!(core::mem::size_of::<UnencryptedCmk>() == UNENCRYPTED_CMK_SIZE_BYTES);
const _: () = assert!(core::mem::size_of::<EncryptedCmk>() == CMK_SIZE_BYTES);
const _: () = assert!(core::mem::size_of::<ShaContext>() == CMB_SHA_CONTEXT_SIZE);
const _: () =
assert!(core::mem::size_of::<EncryptedAesGcmContext>() == CMB_AES_GCM_ENCRYPTED_CONTEXT_SIZE);
const _: () =
assert!(core::mem::size_of::<EncryptedEcdhContext>() == CMB_ECDH_ENCRYPTED_CONTEXT_SIZE);
pub(crate) struct Commands {}
impl Commands {
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn status(drivers: &mut Drivers, resp: &mut [u8]) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
let len = drivers.cryptographic_mailbox.counters.len();
let resp = mutrefbytes::<CmStatusResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.used_usage_storage = len as u32;
resp.total_usage_storage = KEY_USAGE_MAX as u32;
Ok(core::mem::size_of::<CmStatusResp>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn import(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
if cmd_bytes.len() > core::mem::size_of::<CmImportReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmImportReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
let key_usage = CmKeyUsage::from(cmd.key_usage);
match (key_usage, cmd.input_size) {
(CmKeyUsage::Aes | CmKeyUsage::Mldsa, 32) => (),
(CmKeyUsage::Ecdsa, 48) => (),
(CmKeyUsage::Hmac, 48 | 64) => (),
_ => Err(CaliptraError::RUNTIME_CMB_INVALID_KEY_USAGE_AND_SIZE)?,
}
let raw_key = &cmd.input[..cmd.input_size as usize];
let mut unencrypted_cmk = UnencryptedCmk {
version: 1,
length: cmd.input_size as u16,
key_usage: key_usage as u32 as u8,
id: if matches!(key_usage, CmKeyUsage::Aes) {
drivers.cryptographic_mailbox.add_counter()?
} else {
[0u8; 3]
},
usage_counter: 0,
key_material: [0u8; CMK_MAX_KEY_SIZE_BITS / 8],
};
unencrypted_cmk.key_material[..raw_key.len()].copy_from_slice(raw_key);
let encrypted_cmk = drivers.cryptographic_mailbox.encrypt_cmk(
&mut drivers.aes,
&mut drivers.trng,
&unencrypted_cmk,
)?;
let resp = mutrefbytes::<CmImportResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.cmk = transmute!(encrypted_cmk);
Ok(core::mem::size_of::<CmImportResp>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn delete(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
if cmd_bytes.len() != core::mem::size_of::<CmDeleteReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let encrypted_cmk =
EncryptedCmk::ref_from_bytes(&cmd_bytes[core::mem::offset_of!(CmDeleteReq, cmk)..])
.map_err(|_| CaliptraError::RUNTIME_INTERNAL)?;
let decrypted_cmk = drivers.cryptographic_mailbox.decrypt_cmk(
&mut drivers.aes,
&mut drivers.trng,
encrypted_cmk,
)?;
if matches!(
CmKeyUsage::from(decrypted_cmk.key_usage as u32),
CmKeyUsage::Aes
) {
drivers
.cryptographic_mailbox
.delete_counter(decrypted_cmk.key_id())?;
}
let resp = mutrefbytes::<MailboxRespHeader>(resp)?;
*resp = MailboxRespHeader::default();
Ok(core::mem::size_of::<MailboxRespHeader>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn clear(drivers: &mut Drivers, resp: &mut [u8]) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
drivers.cryptographic_mailbox.clear_counters();
let resp = mutrefbytes::<MailboxRespHeader>(resp)?;
*resp = MailboxRespHeader::default();
Ok(core::mem::size_of::<MailboxRespHeader>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn sha_init(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
if cmd_bytes.len() > core::mem::size_of::<CmShaInitReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmShaInitReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
let cm_hash_algorithm = CmHashAlgorithm::from(cmd.hash_algorithm);
if cmd.input_size as usize > cmd.input.len() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut context = ShaContext {
hash_algorithm: cm_hash_algorithm.into(),
..Default::default()
};
let data = &cmd.input[..cmd.input_size as usize];
let data_len = match cm_hash_algorithm {
CmHashAlgorithm::Sha384 => {
let mut op = drivers.sha2_512_384.sha384_digest_init()?;
op.update(data)?;
op.save_buffer(&mut context.input_buffer)?
}
CmHashAlgorithm::Sha512 => {
let mut op = drivers.sha2_512_384.sha512_digest_init()?;
op.update(data)?;
op.save_buffer(&mut context.input_buffer)?
}
_ => {
return Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
};
context.length = data_len as u32;
// copy the intermediate hash if we had enough data to generate one
if data_len >= SHA512_BLOCK_BYTE_SIZE {
let mut intermediate_digest = drivers.sha2_512_384.sha512_read_digest();
intermediate_digest.0.iter_mut().for_each(|x| {
*x = x.swap_bytes();
});
context
.intermediate_hash
.copy_from_slice(intermediate_digest.as_bytes());
}
// Safety: we've copied the state, so it is safe to zeroize
unsafe {
Sha2_512_384::zeroize();
}
let resp = mutrefbytes::<CmShaInitResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.context = transmute!(context);
Ok(core::mem::size_of::<CmShaInitResp>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn sha_update(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
if cmd_bytes.len() > core::mem::size_of::<CmShaUpdateReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmShaUpdateReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
if cmd.input_size as usize > cmd.input.len() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut context: ShaContext = ShaContext::read_from_bytes(&cmd.context)
.map_err(|_| CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
let cm_hash_algorithm = context.hash_algorithm.into();
let data = &cmd.input[..cmd.input_size as usize];
let context_buffer_len = context.length as usize % SHA512_BLOCK_BYTE_SIZE;
let resume_len = context.length as usize - context_buffer_len;
let data_len = match cm_hash_algorithm {
CmHashAlgorithm::Sha384 => {
let mut op = drivers.sha2_512_384.sha384_digest_init()?;
op.resume(
resume_len,
&context.intermediate_hash.into(),
&context.input_buffer[..context_buffer_len],
)?;
op.update(data)?;
op.save_buffer(&mut context.input_buffer)?
}
CmHashAlgorithm::Sha512 => {
let mut op = drivers.sha2_512_384.sha512_digest_init()?;
op.resume(
resume_len,
&context.intermediate_hash.into(),
&context.input_buffer[..context_buffer_len],
)?;
op.update(data)?;
op.save_buffer(&mut context.input_buffer)?
}
_ => Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?,
};
context.length = data_len as u32;
// copy the intermediate hash if we had enough data to generate new one
if context_buffer_len + data.len() >= SHA512_BLOCK_BYTE_SIZE {
let mut intermediate_digest = drivers.sha2_512_384.sha512_read_digest();
intermediate_digest.0.iter_mut().for_each(|x| {
*x = x.swap_bytes();
});
context
.intermediate_hash
.copy_from_slice(intermediate_digest.as_bytes());
}
// Safety: we've copied the state, so it is safe to zeroize
unsafe {
Sha2_512_384::zeroize();
}
let resp = mutrefbytes::<CmShaInitResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.context = transmute!(context);
Ok(core::mem::size_of::<CmShaInitResp>())
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn sha_final(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if !drivers.cryptographic_mailbox.initialized {
Err(CaliptraError::RUNTIME_CMB_NOT_INITIALIZED)?;
}
if cmd_bytes.len() > core::mem::size_of::<CmShaUpdateReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmShaUpdateReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
if cmd.input_size as usize > cmd.input.len() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let context: ShaContext = ShaContext::read_from_bytes(&cmd.context)
.map_err(|_| CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
let cm_hash_algorithm = context.hash_algorithm.into();
let data = &cmd.input[..cmd.input_size as usize];
let mut digest = [0u8; SHA512_HASH_SIZE];
let context_buffer_len = context.length as usize % SHA512_BLOCK_BYTE_SIZE;
let resume_len = context.length as usize - context_buffer_len;
let len = match cm_hash_algorithm {
CmHashAlgorithm::Sha384 => {
let mut op = drivers.sha2_512_384.sha384_digest_init()?;
op.resume(
resume_len,
&context.intermediate_hash.into(),
&context.input_buffer[..context_buffer_len],
)?;
op.update(data)?;
let mut digest32 = Array4x12::default();
op.finalize(&mut digest32)?;
digest[..SHA384_DIGEST_BYTE_SIZE]
.copy_from_slice(&<[u8; SHA384_DIGEST_BYTE_SIZE]>::from(digest32));
SHA384_DIGEST_BYTE_SIZE
}
CmHashAlgorithm::Sha512 => {
let mut op = drivers.sha2_512_384.sha512_digest_init()?;
op.resume(
resume_len,
&context.intermediate_hash.into(),
&context.input_buffer[..context_buffer_len],
)?;
op.update(data)?;
let mut digest32 = Array4x16::default();
op.finalize(&mut digest32)?;
digest.copy_from_slice(&<[u8; SHA512_DIGEST_BYTE_SIZE]>::from(digest32));
SHA512_DIGEST_BYTE_SIZE
}
_ => Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?,
};
// Safety: we've copied the digest, so it is safe to zeroize
unsafe {
Sha2_512_384::zeroize();
}
let resp = mutrefbytes::<CmShaFinalResp>(resp)?;
resp.hdr = MailboxRespHeaderVarSize::default();
resp.hdr.data_len = len as u32;
resp.hash = digest;
resp.partial_len()
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn random_generate(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if cmd_bytes.len() != core::mem::size_of::<CmRandomGenerateReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let cmd = CmRandomGenerateReq::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::RUNTIME_INTERNAL)?;
let size = cmd.size as usize;
if size > MAX_CMB_DATA_SIZE {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let resp = mutrefbytes::<CmRandomGenerateResp>(resp)?;
resp.hdr = MailboxRespHeaderVarSize::default();
resp.hdr.data_len = size as u32;
for i in (0..size).step_by(48) {
let rand: [u8; 48] = drivers.trng.generate()?.into();
let len = rand.len().min(resp.data.len() - i);
// check to prevent panic even though this is impossible
if i > resp.data.len() {
break;
}
resp.data[i..i + len].copy_from_slice(&rand[..len]);
}
resp.partial_len()
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn random_stir(drivers: &mut Drivers, cmd_bytes: &[u8]) -> CaliptraResult<usize> {
if cmd_bytes.len() > core::mem::size_of::<CmRandomStirReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmRandomStirReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
let size = (cmd.input_size as usize).next_multiple_of(MAX_SEED_WORDS * 4);
if size > MAX_CMB_DATA_SIZE {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let additional_data = <[u32; MAX_CMB_DATA_SIZE / 4]>::ref_from_bytes(&cmd.input).unwrap();
drivers.trng.stir(&additional_data[..size / 4])?;
Ok(0)
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub(crate) fn aes_256_encrypt_init(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if cmd_bytes.len() > core::mem::size_of::<CmAesEncryptInitReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmAesEncryptInitReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
if cmd.plaintext_size as usize > MAX_CMB_DATA_SIZE {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mode = CmAesMode::from(cmd.mode);
if matches!(mode, CmAesMode::Cbc) && cmd.plaintext_size as usize % AES_BLOCK_SIZE_BYTES != 0
{
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let plaintext = &cmd.plaintext[..cmd.plaintext_size as usize];
let encrypted_cmk = EncryptedCmk::ref_from_bytes(&cmd.cmk.0[..])
.map_err(|_| CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
let cmk = drivers.cryptographic_mailbox.decrypt_cmk(
&mut drivers.aes,
&mut drivers.trng,
encrypted_cmk,
)?;
let (key, _) = LEArray4x8::ref_from_prefix(&cmk.key_material).unwrap();
let iv: [u8; 16] = drivers.trng.generate()?.as_bytes()[..16]
.try_into()
.unwrap();
let iv: LEArray4x4 = transmute!(iv);
let resp = mutrefbytes::<CmAesEncryptInitResp>(resp)?;
let unencrypted_context = match mode {
CmAesMode::Cbc => drivers.aes.aes_256_cbc(
key,
&iv,
AesOperation::Encrypt,
plaintext,
&mut resp.ciphertext,
)?,
CmAesMode::Ctr => {
drivers
.aes
.aes_256_ctr(key, &iv, 0, plaintext, &mut resp.ciphertext)?
}
_ => Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?,
};
let encrypted_context = drivers.cryptographic_mailbox.encrypt_aes_context(
&mut drivers.aes,
&mut drivers.trng,
&unencrypted_context,
)?;
resp.hdr.hdr = MailboxRespHeader::default();
resp.hdr.iv = iv.into();
resp.hdr.context = transmute!(encrypted_context);
resp.hdr.ciphertext_size = plaintext.len() as u32;
resp.partial_len()
}
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn aes_256_encrypt_update(
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
if cmd_bytes.len() > core::mem::size_of::<CmAesEncryptUpdateReq>() {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let mut cmd = CmAesEncryptUpdateReq::default();
cmd.as_mut_bytes()[..cmd_bytes.len()].copy_from_slice(cmd_bytes);
if cmd.plaintext_size as usize > MAX_CMB_DATA_SIZE {
Err(CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
}
let encrypted_context = EncryptedAesContext::ref_from_bytes(&cmd.context[..])
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/firmware_verify.rs | runtime/src/firmware_verify.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
firmware_verify.rs
Abstract:
File contains FIRMWARE_VERIFY mailbox command.
--*/
use crate::mutrefbytes;
use crate::Drivers;
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_common::mailbox_api::populate_checksum;
use caliptra_common::mailbox_api::MailboxRespHeader;
use caliptra_common::mailbox_api::{FirmwareVerifyResp, FirmwareVerifyResult};
use caliptra_common::verifier::FirmwareImageVerificationEnv;
use caliptra_drivers::{AxiAddr, CaliptraError, CaliptraResult, PersistentData, ResetReason};
use caliptra_image_types::ImageManifest;
use caliptra_image_verify::ImageVerifier;
use caliptra_registers::mbox::enums::MboxStatusE;
use core::mem::size_of;
use zerocopy::{FromBytes, IntoBytes};
/// Source of the firmware image for verification
pub enum VerifySrc {
/// Firmware image is in mailbox SRAM
Mbox,
/// Firmware image is in external memory (MCU SRAM)
External {
/// AXI address where the firmware image is located
axi_address: AxiAddr,
/// Size of the firmware image in bytes
image_size: u32,
},
}
pub struct FirmwareVerifyCmd;
impl FirmwareVerifyCmd {
#[inline(never)]
pub(crate) fn execute(drivers: &mut Drivers, src: VerifySrc) -> CaliptraResult<MboxStatusE> {
let (image_size, image_source) = match src {
VerifySrc::Mbox => {
let raw_data = drivers.mbox.raw_mailbox_contents();
Self::load_manifest_from_mbox(drivers.persistent_data.get_mut(), raw_data)?;
(
drivers.mbox.dlen(),
caliptra_common::verifier::ImageSource::MboxMemory(raw_data),
)
}
VerifySrc::External {
axi_address,
image_size,
} => {
Self::load_manifest_from_external(
drivers.persistent_data.get_mut(),
&mut drivers.dma,
axi_address,
)?;
(
image_size,
caliptra_common::verifier::ImageSource::McuSram(&drivers.dma),
)
}
};
let mut venv = FirmwareImageVerificationEnv {
sha256: &mut drivers.sha256,
sha2_512_384: &mut drivers.sha2_512_384,
sha2_512_384_acc: &mut drivers.sha2_512_384_acc,
soc_ifc: &mut drivers.soc_ifc,
ecc384: &mut drivers.ecc384,
mldsa87: &mut drivers.mldsa87,
data_vault: &drivers.persistent_data.get().rom.data_vault,
pcr_bank: &mut drivers.pcr_bank,
image_source,
persistent_data: drivers.persistent_data.get(),
};
let mut verifier = ImageVerifier::new(&mut venv);
let manifest = drivers.persistent_data.get().rom.manifest2;
let resp = &mut [0u8; core::mem::size_of::<FirmwareVerifyResp>()][..];
let resp = mutrefbytes::<FirmwareVerifyResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
match verifier.verify(&manifest, image_size, ResetReason::UpdateReset) {
Ok(_) => {
// Verification succeeded
resp.verify_result = FirmwareVerifyResult::Success as u32;
}
Err(_) => {
// Verification failed
resp.verify_result = FirmwareVerifyResult::Failure as u32;
}
}
populate_checksum(resp.as_mut_bytes());
// Send the payload
drivers.mbox.write_response(resp.as_bytes())?;
// zero the original resp buffer so as not to leak sensitive data
resp.as_mut_bytes().fill(0);
drivers
.persistent_data
.get_mut()
.rom
.manifest2
.as_mut_bytes()
.fill(0);
Ok(MboxStatusE::DataReady)
}
/// Load manifest from mailbox SRAM
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_mbox(
persistent_data: &mut PersistentData,
fw_payload: &[u8],
) -> CaliptraResult<()> {
if fw_payload.len() < size_of::<ImageManifest>() {
return Err(CaliptraError::IMAGE_VERIFIER_ERR_MANIFEST_SIZE_MISMATCH);
}
persistent_data
.rom
.manifest2
.as_mut_bytes()
.copy_from_slice(fw_payload[..size_of::<ImageManifest>()].as_ref());
Ok(())
}
/// Load manifest from external memory (MCU SRAM) using DMA
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_external(
persistent_data: &mut PersistentData,
dma: &mut caliptra_drivers::Dma,
axi_address: AxiAddr,
) -> CaliptraResult<()> {
let manifest = &mut persistent_data.rom.manifest2;
let manifest_buf = manifest.as_mut_bytes();
// Read manifest from external memory using DMA directly into manifest buffer
let (manifest_words, _) = <[u32]>::mut_from_prefix(manifest_buf).unwrap();
dma.read_buffer(axi_address, manifest_words);
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/ocp_lock/initialize_mek_secret.rs | runtime/src/ocp_lock/initialize_mek_secret.rs | // Licensed under the Apache-2.0 license
use crate::{mutrefbytes, Drivers};
use caliptra_api::mailbox::{
MailboxRespHeader, OcpLockInitializeMekSecretReq, OcpLockInitializeMekSecretResp,
};
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_error::{CaliptraError, CaliptraResult};
use zerocopy::FromBytes;
use super::{Dpk, Sek};
pub struct InitializeMekSecretCmd;
impl InitializeMekSecretCmd {
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn execute(
drivers: &mut Drivers,
cmd_args: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
// TODO(clundin): Add a PauserPrivileges check?
let cmd = OcpLockInitializeMekSecretReq::ref_from_bytes(cmd_args)
.map_err(|_| CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
drivers.ocp_lock_context.create_intermediate_mek_secret(
&mut drivers.hmac,
&mut drivers.trng,
&mut drivers.key_vault,
Sek(cmd.sek),
Dpk(cmd.dpk),
)?;
let resp = mutrefbytes::<OcpLockInitializeMekSecretResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
Ok(core::mem::size_of::<OcpLockInitializeMekSecretResp>())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/ocp_lock/mod.rs | runtime/src/ocp_lock/mod.rs | // Licensed under the Apache-2.0 license
use caliptra_api::mailbox::CommandId;
use caliptra_cfi_lib_git::{cfi_assert, cfi_assert_eq};
use caliptra_common::keyids::ocp_lock::{KEY_ID_EPK, KEY_ID_HEK, KEY_ID_MEK_SECRETS};
use caliptra_drivers::{
cmac_kdf, hmac_kdf, Aes, AesKey, AesOperation, Dma, Hmac, HmacKey, HmacMode, HmacTag,
KeyReadArgs, KeyUsage, KeyVault, KeyWriteArgs, LEArray4x16, LEArray4x8, SocIfc, Trng,
};
use caliptra_error::{CaliptraError, CaliptraResult};
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
use zeroize::ZeroizeOnDrop;
mod derive_mek;
mod get_algorithms;
mod initialize_mek_secret;
pub use derive_mek::DeriveMekCmd;
pub use get_algorithms::GetAlgorithmsCmd;
pub use initialize_mek_secret::InitializeMekSecretCmd;
use crate::Drivers;
/// Represents the SEK type from OCP LOCK.
#[derive(IntoBytes, KnownLayout, Immutable, ZeroizeOnDrop)]
pub struct Sek(pub [u8; 32]);
/// Represents the DPK type from OCP LOCK.
#[derive(IntoBytes, KnownLayout, Immutable, ZeroizeOnDrop)]
pub struct Dpk(pub [u8; 32]);
/// Represents the Intermediate MEK Secret from OCP LOCK.
/// This is constructed from the EPK + DPK.
///
/// NOTE: MPKs will be mixed into `IntermediateMekSecret`
pub struct IntermediateMekSecret;
impl IntermediateMekSecret {
/// Consumes `Self` to produce a `MekSecret`.
fn derive_mek_secret<'a>(
self,
hmac: &mut Hmac,
trng: &mut Trng,
kv: &'a mut KeyVault,
) -> CaliptraResult<MekSecret<'a>> {
hmac_kdf(
hmac,
HmacKey::Key(KeyReadArgs::new(KEY_ID_MEK_SECRETS)),
b"ocp_lock_derived_mek",
None,
trng,
HmacTag::Key(KeyWriteArgs::new(
KEY_ID_MEK_SECRETS,
KeyUsage::default().set_aes_key_en(),
)),
HmacMode::Hmac512,
)?;
Ok(MekSecret { kv })
}
}
/// Represents the MEK Secret from OCP LOCK.
/// This is constructed from `IntermediateMekSecret`
pub struct MekSecret<'a> {
kv: &'a mut KeyVault,
}
impl MekSecret<'_> {
/// Consumes `Self` to produce a `MekSeed`.
/// NOTE: This will erase the `MEK_SECRET` key vault.
fn derive_mek_seed(self, aes: &mut Aes) -> CaliptraResult<MekSeed> {
Ok(MekSeed(cmac_kdf(
aes,
AesKey::KV(KeyReadArgs::new(KEY_ID_MEK_SECRETS)),
b"ocp_lock_mek_seed",
None,
4,
)?))
}
}
impl Drop for MekSecret<'_> {
// From Spec:
// > Held in the Key Vault and zeroized after each use.
fn drop(&mut self) {
// We don't set a write or use lock so this should never fail.
let _ = self.kv.erase_key(KEY_ID_MEK_SECRETS);
}
}
/// Checksum of an `Mek`
#[derive(Default, IntoBytes, KnownLayout, Immutable, ZeroizeOnDrop, PartialEq, Eq)]
pub struct MekChecksum(pub [u8; 16]);
/// Represents the MEK Seed from OCP LOCK.
/// This is constructed from `MekSecret`
#[derive(IntoBytes, KnownLayout, Immutable, ZeroizeOnDrop)]
pub struct MekSeed(LEArray4x16);
impl AsRef<LEArray4x16> for MekSeed {
fn as_ref(&self) -> &LEArray4x16 {
&self.0
}
}
impl MekSeed {
fn checksum(&self, aes: &mut Aes) -> CaliptraResult<MekChecksum> {
let key = self
.0
.as_bytes()
.get(0..32)
.ok_or(CaliptraError::RUNTIME_OCP_LOCK_INVALID_MEK_SEED_SIZE)?;
let key = LEArray4x8::ref_from_bytes(key)
.map_err(|_| CaliptraError::RUNTIME_OCP_LOCK_INVALID_MEK_SEED_SIZE)?;
let mut output = [0; 16];
aes.aes_256_ecb(
AesKey::Array(key),
AesOperation::Encrypt,
&[0; 16],
&mut output,
)?;
Ok(MekChecksum(output))
}
}
/// Represents the EPK type from OCP LOCK.
/// This is constructed from the HEK + SEK.
struct Epk<'a> {
kv: &'a mut KeyVault,
}
impl<'a> Epk<'a> {
/// Derive EPK. The EPK is only valid for the lifetime of `Self`.
fn new(
hmac: &mut Hmac,
trng: &mut Trng,
kv: &'a mut KeyVault,
sek: Sek,
) -> CaliptraResult<Self> {
hmac_kdf(
hmac,
HmacKey::Key(KeyReadArgs::new(KEY_ID_HEK)),
b"ocp_lock_epk",
Some(sek.as_bytes()),
trng,
HmacTag::Key(KeyWriteArgs::new(
KEY_ID_EPK,
KeyUsage::default().set_hmac_key_en(),
)),
HmacMode::Hmac512,
)?;
Ok(Self { kv })
}
/// Consumes `Self` and DPK to produce a `IntermediateMekSecret`
fn derive_intermediate_mek_secret(
self,
hmac: &mut Hmac,
trng: &mut Trng,
dpk: Dpk,
) -> CaliptraResult<IntermediateMekSecret> {
hmac_kdf(
hmac,
HmacKey::Key(KeyReadArgs::new(KEY_ID_EPK)),
b"ocp_lock_intermediate_mek_secret",
Some(dpk.as_bytes()),
trng,
HmacTag::Key(KeyWriteArgs::new(
KEY_ID_MEK_SECRETS,
KeyUsage::default().set_hmac_key_en(),
)),
HmacMode::Hmac512,
)?;
Ok(IntermediateMekSecret)
}
}
impl Drop for Epk<'_> {
// From Spec:
// > Held in the Key Vault and zeroized after each use.
fn drop(&mut self) {
// We don't set a write or use lock so this should never fail.
let _ = self.kv.erase_key(KEY_ID_EPK);
}
}
/// Provides OCP LOCK functionalities.
pub struct OcpLockContext {
/// OCP LOCK is supported on both HW and FW
available: bool,
/// HEK is available
hek_available: bool,
/// Holds Intermediate Mek Secret, initialized by calling INITIALIZE_MEK_SECRET. Some commands do not work until
/// `intermediate_secret` has a value.
intermediate_secret: Option<IntermediateMekSecret>,
}
impl OcpLockContext {
pub fn new(soc_ifc: &SocIfc, hek_available: bool) -> Self {
let available = cfg!(feature = "ocp-lock") && soc_ifc.ocp_lock_enabled();
Self {
available,
intermediate_secret: None,
hek_available,
}
}
/// Checks if the OCP lock is available.
///
/// Returns `true` if the "ocp-lock" feature is enabled and the OCP lock is enabled in the SoC.
pub fn available(&self) -> bool {
self.available
}
/// Creates an MEK intermediate secret from `HEK`, `SEK` and `DPK`.
pub fn create_intermediate_mek_secret(
&mut self,
hmac: &mut Hmac,
trng: &mut Trng,
kv: &mut KeyVault,
sek: Sek,
dpk: Dpk,
) -> CaliptraResult<()> {
if !self.hek_available {
return Err(CaliptraError::RUNTIME_OCP_LOCK_HEK_UNAVAILABLE);
} else {
cfi_assert!(self.hek_available);
}
let epk = Epk::new(hmac, trng, kv, sek)?;
let intermediate_secret = epk.derive_intermediate_mek_secret(hmac, trng, dpk)?;
self.intermediate_secret = Some(intermediate_secret);
Ok(())
}
/// Derives an MEK
///
/// NOTE: This operation will consume `intermediate_secret` and erase the MEK secret key vault on
/// completion.
// TODO(clundin): Maybe we will want to split the MEK
// release into a separate step since other flows will
// need it. This will reduce the args.
#[allow(clippy::too_many_arguments)]
pub fn derive_mek(
&mut self,
aes: &mut Aes,
dma: &mut Dma,
hmac: &mut Hmac,
trng: &mut Trng,
kv: &mut KeyVault,
soc: &mut SocIfc,
expect_mek_checksum: MekChecksum,
) -> CaliptraResult<MekChecksum> {
// After `intermediate_secret` is consumed a new MEK cannot be created without first calling
// `OCP_LOCK_INITIALIZE_MEK_SECRET` so we take it.
let Some(intermediate_secret) = self.intermediate_secret.take() else {
return Err(CaliptraError::RUNTIME_OCP_LOCK_MEK_NOT_INITIALIZED);
};
let mek_secret = intermediate_secret.derive_mek_secret(hmac, trng, kv)?;
let mek_seed = mek_secret.derive_mek_seed(aes)?;
let checksum = mek_seed.checksum(aes)?;
// If `expect_mek_checksum` is all zeros, skip checking that the MEK checksum matches.
// `expect_mek_checksum` should match the `checksum` that was derived.
// Otherwise we need to report an error.
if expect_mek_checksum != MekChecksum::default() && expect_mek_checksum != checksum {
return Err(CaliptraError::RUNTIME_OCP_LOCK_MEK_CHKSUM_FAIL);
}
// Decrypt MEK from MEK seed using MDK.
aes.aes_256_ecb_decrypt_kv(mek_seed.as_ref())?;
// Release MEK to Encryption Engine.
dma.ocp_lock_key_vault_release(soc);
Ok(checksum)
}
}
/// Entry point for OCP LOCK commands
pub fn command_handler(
cmd_id: CommandId,
drivers: &mut Drivers,
cmd_bytes: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
// If we have not enabled 'ocp-lock' we don't want the compiler to link these commands, so exit
// the function early.
if !cfg!(feature = "ocp-lock") || !drivers.ocp_lock_context.available() {
Err(CaliptraError::RUNTIME_OCP_LOCK_UNSUPPORTED_COMMAND)?;
}
match cmd_id {
CommandId::OCP_LOCK_GET_ALGORITHMS => GetAlgorithmsCmd::execute(resp),
CommandId::OCP_LOCK_INITIALIZE_MEK_SECRET => {
InitializeMekSecretCmd::execute(drivers, cmd_bytes, resp)
}
CommandId::OCP_LOCK_DERIVE_MEK => DeriveMekCmd::execute(drivers, cmd_bytes, resp),
_ => Err(CaliptraError::RUNTIME_UNIMPLEMENTED_COMMAND),
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/ocp_lock/get_algorithms.rs | runtime/src/ocp_lock/get_algorithms.rs | // Licensed under the Apache-2.0 license
use caliptra_api::mailbox::{
AccessKeySizes, EndorsementAlgorithms, HpkeAlgorithms, OcpLockGetAlgorithmsResp,
};
use caliptra_error::CaliptraResult;
use crate::mutrefbytes;
pub struct GetAlgorithmsCmd;
impl GetAlgorithmsCmd {
#[cfg_attr(not(feature = "no-cfi"), caliptra_cfi_derive_git::cfi_impl_fn)]
#[inline(never)]
pub fn execute(resp: &mut [u8]) -> CaliptraResult<usize> {
let resp = mutrefbytes::<OcpLockGetAlgorithmsResp>(resp)?;
resp.access_key_sizes = AccessKeySizes::LEN_256;
resp.endorsement_algorithms = EndorsementAlgorithms::all();
resp.hpke_algorithms = HpkeAlgorithms::all();
Ok(core::mem::size_of::<OcpLockGetAlgorithmsResp>())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/src/ocp_lock/derive_mek.rs | runtime/src/ocp_lock/derive_mek.rs | // Licensed under the Apache-2.0 license
use crate::{mutrefbytes, Drivers};
use caliptra_api::mailbox::{MailboxRespHeader, OcpLockDeriveMekReq, OcpLockDeriveMekResp};
use caliptra_cfi_derive_git::cfi_impl_fn;
use caliptra_error::{CaliptraError, CaliptraResult};
use zerocopy::FromBytes;
use super::MekChecksum;
pub struct DeriveMekCmd;
impl DeriveMekCmd {
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
pub(crate) fn execute(
drivers: &mut Drivers,
cmd_args: &[u8],
resp: &mut [u8],
) -> CaliptraResult<usize> {
// TODO(clundin): Add a PauserPrivileges check?
let cmd = OcpLockDeriveMekReq::ref_from_bytes(cmd_args)
.map_err(|_| CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS)?;
let expected_mek_checksum = MekChecksum(cmd.mek_checksum);
let checksum = drivers.ocp_lock_context.derive_mek(
&mut drivers.aes,
&mut drivers.dma,
&mut drivers.hmac,
&mut drivers.trng,
&mut drivers.key_vault,
&mut drivers.soc_ifc,
expected_mek_checksum,
)?;
let resp = mutrefbytes::<OcpLockDeriveMekResp>(resp)?;
resp.hdr = MailboxRespHeader::default();
resp.mek_checksum = checksum.0;
Ok(core::mem::size_of::<OcpLockDeriveMekResp>())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_recovery_flow.rs | runtime/tests/runtime_integration_tests/test_recovery_flow.rs | // Licensed under the Apache-2.0 license
use crate::common::{run_rt_test, RuntimeTestArgs};
use crate::test_set_auth_manifest::create_auth_manifest_with_metadata;
use caliptra_auth_man_types::{AuthManifestImageMetadata, ImageMetadataFlags};
use caliptra_emu_bus::{Device, EventData};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{HwModel, InitParams};
use caliptra_image_crypto::OsslCrypto as Crypto;
use caliptra_image_gen::from_hw_format;
use caliptra_image_gen::ImageGeneratorCrypto;
use zerocopy::IntoBytes;
const RT_READY_FOR_COMMANDS: u32 = 0x600;
#[cfg_attr(
any(
feature = "verilator",
feature = "fpga_realtime",
feature = "fpga_subsystem"
),
ignore
)]
#[test]
fn test_loads_mcu_fw() {
// Test that the recovery flow runs and loads MCU's firmware
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let mut args = RuntimeTestArgs::default();
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
args.init_params = Some(InitParams {
rom: &rom,
subsystem_mode: true,
..Default::default()
});
args.soc_manifest = Some(soc_manifest);
args.mcu_fw_image = Some(&mcu_fw);
let mut model = run_rt_test(args);
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
// check that we got an MCU write
let events = model.events_from_caliptra();
let mut found = false;
for event in events {
if event.dest == Device::MCU && matches!(event.event, EventData::MemoryWrite { .. }) {
found = true;
break;
}
}
assert!(found);
}
#[cfg_attr(
any(
feature = "verilator",
feature = "fpga_realtime",
feature = "fpga_subsystem"
),
ignore
)]
#[test]
fn test_mcu_fw_bad_signature() {
// Test that the recovery flow runs and loads MCU's firmware
let mcu_fw = vec![1, 2, 3, 4];
let bad_mcu_fw = vec![5, 6, 7, 8];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
// add a different digest to the to the SoC manifest
let digest = from_hw_format(&crypto.sha384_digest(&bad_mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let mut args = RuntimeTestArgs::default();
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
args.init_params = Some(InitParams {
rom: &rom,
subsystem_mode: true,
..Default::default()
});
args.soc_manifest = Some(soc_manifest);
args.mcu_fw_image = Some(&mcu_fw);
args.successful_reach_rt = false;
let mut model = run_rt_test(args);
model.step_until_fatal_error(
CaliptraError::IMAGE_VERIFIER_ERR_RUNTIME_DIGEST_MISMATCH.into(),
30_000_000,
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_get_idev_csr.rs | runtime/tests/runtime_integration_tests/test_get_idev_csr.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_builder::{get_ci_rom_version, CiRomVersion};
use caliptra_common::mailbox_api::{CommandId, GetIdevCsrResp, MailboxReqHeader};
use caliptra_drivers::{Ecc384IdevIdCsr, MfgFlags, Mldsa87IdevIdCsr};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{HwModel, ModelError};
use caliptra_runtime::RtBootStatus;
use openssl::x509::X509Req;
use zerocopy::IntoBytes;
use crate::common::{run_rt_test, RuntimeTestArgs};
#[test]
fn test_get_ecc_csr() {
// `run_rt_test` is responsibly for clearing the CSR bit.
// Caliptra will wait until the CSR bit is cleared during startup.
let args = RuntimeTestArgs {
test_mfg_flags: Some(MfgFlags::GENERATE_IDEVID_CSR),
..Default::default()
};
let mut model = run_rt_test(args);
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_ECC384_CSR),
&[],
),
};
let result = model.mailbox_execute(CommandId::GET_IDEV_ECC384_CSR.into(), payload.as_bytes());
match get_ci_rom_version() {
CiRomVersion::Latest => {
let response = result.unwrap().unwrap();
let mut get_idv_csr_resp = GetIdevCsrResp::default();
get_idv_csr_resp.as_mut_bytes()[..response.len()].copy_from_slice(&response);
assert_ne!(
Ecc384IdevIdCsr::UNPROVISIONED_CSR,
get_idv_csr_resp.data_size
);
assert_ne!(0, get_idv_csr_resp.data_size);
let csr_bytes = &get_idv_csr_resp.data[..get_idv_csr_resp.data_size as usize];
assert_ne!([0; 512], csr_bytes);
assert!(X509Req::from_der(csr_bytes).is_ok());
}
};
}
#[test]
fn test_get_mldsa_csr() {
// `run_rt_test` is responsibly for clearing the CSR bit.
// Caliptra will wait until the CSR bit is cleared during startup.
let args = RuntimeTestArgs {
test_mfg_flags: Some(MfgFlags::GENERATE_IDEVID_CSR),
..Default::default()
};
let mut model = run_rt_test(args);
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_MLDSA87_CSR),
&[],
),
};
let result = model.mailbox_execute(CommandId::GET_IDEV_MLDSA87_CSR.into(), payload.as_bytes());
match get_ci_rom_version() {
CiRomVersion::Latest => {
let response = result.unwrap().unwrap();
let mut get_idv_csr_resp = GetIdevCsrResp::default();
get_idv_csr_resp.as_mut_bytes()[..response.len()].copy_from_slice(&response);
assert_ne!(
Mldsa87IdevIdCsr::UNPROVISIONED_CSR,
get_idv_csr_resp.data_size
);
assert_ne!(0, get_idv_csr_resp.data_size);
let csr_bytes = &get_idv_csr_resp.data[..get_idv_csr_resp.data_size as usize];
assert_ne!([0; 512], csr_bytes);
assert!(X509Req::from_der(csr_bytes).is_ok());
}
};
}
#[test]
fn test_missing_csr() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_ECC384_CSR),
&[],
),
};
let response = model
.mailbox_execute(CommandId::GET_IDEV_ECC384_CSR.into(), payload.as_bytes())
.unwrap_err();
match get_ci_rom_version() {
CiRomVersion::Latest => assert_eq!(
response,
ModelError::MailboxCmdFailed(CaliptraError::RUNTIME_GET_IDEV_ID_UNPROVISIONED.into())
),
};
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_MLDSA87_CSR),
&[],
),
};
let response = model
.mailbox_execute(CommandId::GET_IDEV_MLDSA87_CSR.into(), payload.as_bytes())
.unwrap_err();
match get_ci_rom_version() {
CiRomVersion::Latest => assert_eq!(
response,
ModelError::MailboxCmdFailed(CaliptraError::RUNTIME_GET_IDEV_ID_UNPROVISIONED.into())
),
};
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_get_fmc_alias_csr.rs | runtime/tests/runtime_integration_tests/test_get_fmc_alias_csr.rs | // Licensed under the Apache-2.0 license
use crate::common::get_certs;
use caliptra_api::mailbox::{GetFmcAliasEccCsrReq, GetFmcAliasMldsaCsrReq};
use caliptra_common::mailbox_api::{GetRtAliasEcc384CertReq, GetRtAliasMlDsa87CertReq};
use caliptra_drivers::{FmcAliasCsrs, ECC384_MAX_FMC_ALIAS_CSR_SIZE, MLDSA87_MAX_CSR_SIZE};
use caliptra_hw_model::DefaultHwModel;
use openssl::{
pkey::{PKey, Public},
x509::{X509Req, X509},
};
use crate::common::{run_rt_test, RuntimeTestArgs};
#[test]
fn test_get_fmc_alias_csr() {
fn verify_rt_ecc_cert(model: &mut DefaultHwModel, pub_key: PKey<Public>) {
let get_rt_alias_cert_resp = get_certs::<GetRtAliasEcc384CertReq>(model);
assert_ne!(0, get_rt_alias_cert_resp.data_size);
let der = &get_rt_alias_cert_resp.data[..get_rt_alias_cert_resp.data_size as usize];
let cert = X509::from_der(der).unwrap();
assert!(
cert.verify(&pub_key).unwrap(),
"Invalid public key. Unable to verify RT Alias ECC Cert",
);
}
fn verify_rt_mldsa_cert(model: &mut DefaultHwModel, pub_key: PKey<Public>) {
let get_rt_alias_cert_resp = get_certs::<GetRtAliasMlDsa87CertReq>(model);
assert_ne!(0, get_rt_alias_cert_resp.data_size);
let der = &get_rt_alias_cert_resp.data[..get_rt_alias_cert_resp.data_size as usize];
let cert = X509::from_der(der).unwrap();
assert!(
cert.verify(&pub_key).unwrap(),
"Invalid public key. Unable to verify RT Alias MLDSA Cert",
);
}
fn get_fmc_alias_ecc_csr(model: &mut DefaultHwModel) -> X509Req {
let get_fmc_alias_csr_resp = get_certs::<GetFmcAliasEccCsrReq>(model);
assert_ne!(
FmcAliasCsrs::UNPROVISIONED_CSR,
get_fmc_alias_csr_resp.data_size
);
assert_ne!(0, get_fmc_alias_csr_resp.data_size);
let csr_der = &get_fmc_alias_csr_resp.data[..get_fmc_alias_csr_resp.data_size as usize];
let csr = X509Req::from_der(csr_der).unwrap();
assert_ne!([0; ECC384_MAX_FMC_ALIAS_CSR_SIZE], csr_der);
csr
}
fn get_fmc_alias_mldsa_csr(model: &mut DefaultHwModel) -> X509Req {
let get_fmc_alias_csr_resp = get_certs::<GetFmcAliasMldsaCsrReq>(model);
assert_ne!(
FmcAliasCsrs::UNPROVISIONED_CSR,
get_fmc_alias_csr_resp.data_size
);
assert_ne!(0, get_fmc_alias_csr_resp.data_size);
let csr_der = &get_fmc_alias_csr_resp.data[..get_fmc_alias_csr_resp.data_size as usize];
let csr = openssl::x509::X509Req::from_der(csr_der).unwrap();
assert_ne!([0; MLDSA87_MAX_CSR_SIZE], csr_der);
csr
}
let mut model = run_rt_test(RuntimeTestArgs::default());
// ECC
let csr = get_fmc_alias_ecc_csr(&mut model);
let pubkey = csr.public_key().unwrap();
assert!(
csr.verify(&pubkey).unwrap(),
"Invalid public key. Unable to verify FMC Alias ECC CSR",
);
verify_rt_ecc_cert(&mut model, pubkey);
// MLDSA
let csr = get_fmc_alias_mldsa_csr(&mut model);
let pubkey = csr.public_key().unwrap();
assert!(
csr.verify(&pubkey).unwrap(),
"Invalid public key. Unable to verify FMC Alias MLDSA CSR",
);
verify_rt_mldsa_cert(&mut model, pubkey);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_tagging.rs | runtime/tests/runtime_integration_tests/test_tagging.rs | // Licensed under the Apache-2.0 license
use crate::common::{assert_error, execute_dpe_cmd, run_rt_test, DpeResult, RuntimeTestArgs};
use caliptra_common::mailbox_api::{
CommandId, GetTaggedTciReq, GetTaggedTciResp, MailboxReq, MailboxReqHeader, TagTciReq,
};
use caliptra_hw_model::HwModel;
use dpe::{
commands::{Command, DeriveContextCmd, DeriveContextFlags, DestroyCtxCmd},
context::ContextHandle,
response::Response,
DPE_PROFILE,
};
use zerocopy::FromBytes;
const TAG: u32 = 1;
const INVALID_TAG: u32 = 2;
const DEFAULT_HANDLE: [u8; 16] = [0u8; 16];
const BAD_HANDLE: [u8; 16] = [1u8; 16];
#[test]
fn test_tagging_default_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Tag default context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// get tcis of default context
let mut cmd = MailboxReq::GetTaggedTci(GetTaggedTciReq {
hdr: MailboxReqHeader { chksum: 0 },
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::DPE_GET_TAGGED_TCI),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We expected a response");
let _ = GetTaggedTciResp::read_from_bytes(resp.as_slice()).unwrap();
}
#[test]
fn test_tagging_a_tagged_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Tag default context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// Check that tagging a tagged context fails
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: INVALID_TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_CONTEXT_ALREADY_TAGGED,
resp,
);
}
#[test]
fn test_duplicate_tag() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Tag default context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// Check that adding a duplicate tag fails
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_DUPLICATE_TAG,
resp,
);
}
#[test]
fn test_get_tagged_tci_on_non_existent_tag() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Check that DPE_GET_TAGGED_TCI fails if the tag does not exist
let mut cmd = MailboxReq::GetTaggedTci(GetTaggedTciReq {
hdr: MailboxReqHeader { chksum: 0 },
tag: INVALID_TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::DPE_GET_TAGGED_TCI),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_TAGGING_FAILURE,
resp,
);
}
#[test]
fn test_tagging_inactive_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// check that we cannot tag an inactive context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: BAD_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_TAGGING_FAILURE,
resp,
);
}
#[test]
fn test_tagging_destroyed_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Tag default context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// destroy tagged context
let destroy_ctx_cmd = DestroyCtxCmd {
handle: ContextHandle::default(),
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DestroyCtx(&destroy_ctx_cmd),
DpeResult::Success,
);
let Some(Response::DestroyCtx(_)) = resp else {
panic!("Wrong response type!");
};
// check that we cannot get tagged tci for a destroyed context
let mut cmd = MailboxReq::GetTaggedTci(GetTaggedTciReq {
hdr: MailboxReqHeader { chksum: 0 },
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::DPE_GET_TAGGED_TCI),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_TAGGING_FAILURE,
resp,
);
}
#[test]
fn test_tagging_retired_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// retire context via DeriveContext
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0u8; DPE_PROFILE.hash_size()],
flags: DeriveContextFlags::empty(),
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(derive_context_resp)) = resp else {
panic!("Wrong response type!");
};
let new_handle = derive_context_resp.handle;
// check that we cannot tag retired context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: DEFAULT_HANDLE,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_TAGGING_FAILURE,
resp,
);
// tag new context
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: new_handle.0,
tag: TAG,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// retire tagged context via derive child
let derive_context_cmd = DeriveContextCmd {
handle: new_handle,
data: [0u8; DPE_PROFILE.hash_size()],
flags: DeriveContextFlags::empty(),
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(_)) = resp else {
panic!("Wrong response type!");
};
// check that we can get tagged tci for a retired context
let mut cmd = MailboxReq::GetTaggedTci(GetTaggedTciReq {
hdr: MailboxReqHeader { chksum: 0 },
tag: TAG,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::DPE_GET_TAGGED_TCI),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We expected a response");
let _ = GetTaggedTciResp::read_from_bytes(resp.as_slice()).unwrap();
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_populate_idev.rs | runtime/tests/runtime_integration_tests/test_populate_idev.rs | // Licensed under the Apache-2.0 license
use crate::common::{
execute_dpe_cmd, generate_test_x509_cert, run_rt_test, DpeResult, RuntimeTestArgs,
};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
CommandId, MailboxReq, MailboxReqHeader, PopulateIdevEcc384CertReq, PopulateIdevMldsa87CertReq,
};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{DefaultHwModel, HwModel};
use caliptra_runtime::RtBootStatus;
use dpe::{
commands::{Command, GetCertificateChainCmd},
response::Response,
};
use openssl::{
ec::{EcGroup, EcKey},
nid::Nid,
pkey::{PKey, Private},
pkey_ml_dsa::{PKeyMlDsaBuilder, Variant},
x509::X509,
};
use rand::Rng;
fn get_full_cert_chain(model: &mut DefaultHwModel, out: &mut [u8; 4096]) -> usize {
// first half
let get_cert_chain_cmd = GetCertificateChainCmd {
offset: 0,
size: 2048,
};
let resp = execute_dpe_cmd(
model,
&mut Command::GetCertificateChain(&get_cert_chain_cmd),
DpeResult::Success,
);
let Some(Response::GetCertificateChain(cert_chunk_1)) = resp else {
panic!("Wrong response type!");
};
out[..cert_chunk_1.certificate_size as usize]
.copy_from_slice(&cert_chunk_1.certificate_chain[..cert_chunk_1.certificate_size as usize]);
// second half
let get_cert_chain_cmd = GetCertificateChainCmd {
offset: cert_chunk_1.certificate_size,
size: 2048,
};
let resp = execute_dpe_cmd(
model,
&mut Command::GetCertificateChain(&get_cert_chain_cmd),
DpeResult::Success,
);
let Some(Response::GetCertificateChain(cert_chunk_2)) = resp else {
panic!("Wrong response type!");
};
out[cert_chunk_1.certificate_size as usize
..cert_chunk_1.certificate_size as usize + cert_chunk_2.certificate_size as usize]
.copy_from_slice(&cert_chunk_2.certificate_chain[..cert_chunk_2.certificate_size as usize]);
cert_chunk_1.certificate_size as usize + cert_chunk_2.certificate_size as usize
}
// Will panic if any of the cert chain chunks is not a valid X.509 cert
fn parse_cert_chain(cert_chain: &[u8], cert_chain_size: usize, expected_num_certs: u32) {
let mut i = 0;
let mut cert_count = 0;
while i < cert_chain_size {
let curr_cert = X509::from_der(&cert_chain[i..]).unwrap();
i += curr_cert.to_der().unwrap().len();
cert_count += 1;
}
assert_eq!(expected_num_certs, cert_count);
}
#[test]
fn test_populate_idev_ecc_cert_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cert_chain_without_idev_cert = [0u8; 4096];
let cert_chain_len_without_idev_cert =
get_full_cert_chain(&mut model, &mut cert_chain_without_idev_cert);
// generate test idev cert
let ec_group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let ec_key = PKey::from_ec_key(EcKey::generate(&ec_group).unwrap()).unwrap();
let cert = generate_test_x509_cert(&ec_key);
// copy der encoded idev cert
let cert_bytes = cert.to_der().unwrap();
let mut cert_slice = [0u8; PopulateIdevEcc384CertReq::MAX_CERT_SIZE];
cert_slice[..cert_bytes.len()].copy_from_slice(&cert_bytes);
let mut pop_idev_cmd = MailboxReq::PopulateIdevEcc384Cert(PopulateIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
cert_size: cert_bytes.len() as u32,
cert: cert_slice,
});
pop_idev_cmd.populate_chksum().unwrap();
// call populate idev cert so that the idev cert is added to the certificate chain
model
.mailbox_execute(
u32::from(CommandId::POPULATE_IDEV_ECC384_CERT),
pop_idev_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut cert_chain_with_idev_cert = [0u8; 4096];
let cert_chain_len_with_idev_cert =
get_full_cert_chain(&mut model, &mut cert_chain_with_idev_cert);
// read idev cert from prefix of cert chain and parse it as X509
let idev_len = cert_chain_len_with_idev_cert - cert_chain_len_without_idev_cert;
let idev_cert = X509::from_der(&cert_chain_with_idev_cert[..idev_len]).unwrap();
assert_eq!(idev_cert, cert);
// ensure rest of cert chain is not corrupted
assert_eq!(
cert_chain_without_idev_cert[..cert_chain_len_without_idev_cert],
cert_chain_with_idev_cert[idev_len..cert_chain_len_with_idev_cert]
);
// expect there to be 3 certs in the cert chain - ldevid, fmc alias, rt alias
parse_cert_chain(
&cert_chain_with_idev_cert[idev_len..],
cert_chain_len_with_idev_cert - idev_len,
3,
);
// expect there to be 4 certs in the cert chain - idevid, ldevid, fmc alias, rt alias
parse_cert_chain(&cert_chain_with_idev_cert, cert_chain_len_with_idev_cert, 4);
}
#[test]
fn test_populate_idev_ecc_cert_size_too_big() {
// Test with cert_size too big.
let mut pop_idev_cmd = MailboxReq::PopulateIdevEcc384Cert(PopulateIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
cert_size: PopulateIdevEcc384CertReq::MAX_CERT_SIZE as u32 + 1,
cert: [0u8; PopulateIdevEcc384CertReq::MAX_CERT_SIZE],
});
assert_eq!(
pop_idev_cmd.populate_chksum(),
Err(CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE)
);
}
fn mldsa_keygen() -> PKey<Private> {
let mut rng = rand::thread_rng();
let seed: [u8; 32] = rng.gen();
PKeyMlDsaBuilder::<Private>::from_seed(Variant::MlDsa87, &seed)
.unwrap()
.build()
.unwrap()
}
#[test]
fn test_populate_idev_mldsa_cert_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Generate test idev cert.
let private_key = mldsa_keygen();
let cert = generate_test_x509_cert(&private_key);
// Copy der encoded idev cert.
let cert_bytes = cert.to_der().unwrap();
println!("generate_test_x509_cert cert_size: {}", cert_bytes.len());
let mut cert_slice = [0u8; PopulateIdevMldsa87CertReq::MAX_CERT_SIZE];
cert_slice[..cert_bytes.len()].copy_from_slice(&cert_bytes);
let mut pop_idev_cmd = MailboxReq::PopulateIdevMldsa87Cert(PopulateIdevMldsa87CertReq {
hdr: MailboxReqHeader { chksum: 0 },
cert_size: cert_bytes.len() as u32,
cert: cert_slice,
});
pop_idev_cmd.populate_chksum().unwrap();
// Call populate idev cert so that the idev cert is added to the certificate chain.
model
.mailbox_execute(
u32::from(CommandId::POPULATE_IDEV_MLDSA87_CERT),
pop_idev_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut cert_chain_with_idev_cert = [0u8; 4096];
let cert_chain_len_with_idev_cert =
get_full_cert_chain(&mut model, &mut cert_chain_with_idev_cert);
// Expect there to be 3 certs in the cert chain: ldevid, fmc alias, rt alias.
parse_cert_chain(&cert_chain_with_idev_cert, cert_chain_len_with_idev_cert, 3);
}
#[test]
fn test_populate_idev_mldsa_cert_size_too_big() {
// Test with cert_size too big.
let mut pop_idev_cmd = MailboxReq::PopulateIdevMldsa87Cert(PopulateIdevMldsa87CertReq {
hdr: MailboxReqHeader { chksum: 0 },
cert_size: PopulateIdevMldsa87CertReq::MAX_CERT_SIZE as u32 + 1,
cert: [0u8; PopulateIdevMldsa87CertReq::MAX_CERT_SIZE],
});
assert_eq!(
pop_idev_cmd.populate_chksum(),
Err(CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE)
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_certify_key_extended.rs | runtime/tests/runtime_integration_tests/test_certify_key_extended.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
AddSubjectAltNameReq, CertifyKeyExtendedFlags, CertifyKeyExtendedReq, CertifyKeyExtendedResp,
CommandId, MailboxReq, MailboxReqHeader,
};
use caliptra_hw_model::HwModel;
use caliptra_runtime::{AddSubjectAltNameCmd, RtBootStatus};
use dpe::{
commands::{CertifyKeyCmd, CertifyKeyFlags},
context::ContextHandle,
response::CertifyKeyResp,
};
use x509_parser::{
certificate::X509Certificate, extensions::GeneralName, oid_registry::asn1_rs::FromDer,
};
use zerocopy::{FromBytes, IntoBytes, TryFromBytes};
use crate::common::{assert_error, run_rt_test, RuntimeTestArgs, TEST_LABEL};
#[test]
fn test_dmtf_other_name_validation_fail() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let dmtf_device_info_utf8 = "abc:def:ghi:";
let dmtf_device_info_bytes = dmtf_device_info_utf8.as_bytes();
let mut dmtf_device_info = [0u8; AddSubjectAltNameReq::MAX_DEVICE_INFO_LEN];
dmtf_device_info[..dmtf_device_info_bytes.len()].copy_from_slice(dmtf_device_info_bytes);
let mut cmd = MailboxReq::AddSubjectAltName(AddSubjectAltNameReq {
hdr: MailboxReqHeader { chksum: 0 },
dmtf_device_info_size: dmtf_device_info_bytes.len() as u32,
dmtf_device_info,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::ADD_SUBJECT_ALT_NAME),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_DMTF_DEVICE_INFO_VALIDATION_FAILED,
resp,
);
}
#[test]
fn test_dmtf_other_name_extension_present() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let dmtf_device_info_utf8 = "ChipsAlliance:Caliptra:0123456789";
let dmtf_device_info_bytes = dmtf_device_info_utf8.as_bytes();
let mut dmtf_device_info = [0u8; AddSubjectAltNameReq::MAX_DEVICE_INFO_LEN];
dmtf_device_info[..dmtf_device_info_bytes.len()].copy_from_slice(dmtf_device_info_bytes);
let mut cmd = MailboxReq::AddSubjectAltName(AddSubjectAltNameReq {
hdr: MailboxReqHeader { chksum: 0 },
dmtf_device_info_size: dmtf_device_info_bytes.len() as u32,
dmtf_device_info,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::ADD_SUBJECT_ALT_NAME),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let mut cmd = MailboxReq::CertifyKeyExtended(CertifyKeyExtendedReq {
hdr: MailboxReqHeader { chksum: 0 },
certify_key_req: certify_key_cmd.as_bytes().try_into().unwrap(),
flags: CertifyKeyExtendedFlags::DMTF_OTHER_NAME,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CERTIFY_KEY_EXTENDED),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let certify_key_extended_resp =
CertifyKeyExtendedResp::read_from_bytes(resp.as_slice()).unwrap();
let certify_key_resp =
CertifyKeyResp::try_read_from_bytes(&certify_key_extended_resp.certify_key_resp[..])
.unwrap();
let (_, cert) =
X509Certificate::from_der(&certify_key_resp.cert[..certify_key_resp.cert_size as usize])
.unwrap();
let ext = cert.subject_alternative_name().unwrap().unwrap();
assert!(!ext.critical);
let san = ext.value;
assert_eq!(san.general_names.len(), 1);
let general_name = san.general_names.first().unwrap();
match general_name {
GeneralName::OtherName(oid, other_name_value) => {
assert_eq!(oid.as_bytes(), AddSubjectAltNameCmd::DMTF_OID);
// skip first 4 der encoding bytes
assert_eq!(&other_name_value[4..], dmtf_device_info_bytes);
}
_ => panic!("Wrong SubjectAlternativeName"),
};
}
#[test]
fn test_dmtf_other_name_extension_not_present() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
// Check that otherName extension is not present if not provided by ADD_SUBJECT_ALT_NAME
let mut cmd = MailboxReq::CertifyKeyExtended(CertifyKeyExtendedReq {
hdr: MailboxReqHeader { chksum: 0 },
certify_key_req: certify_key_cmd.as_bytes().try_into().unwrap(),
flags: CertifyKeyExtendedFlags::DMTF_OTHER_NAME,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CERTIFY_KEY_EXTENDED),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let certify_key_extended_resp =
CertifyKeyExtendedResp::read_from_bytes(resp.as_slice()).unwrap();
let certify_key_resp =
CertifyKeyResp::try_read_from_bytes(&certify_key_extended_resp.certify_key_resp[..])
.unwrap();
let (_, cert) =
X509Certificate::from_der(&certify_key_resp.cert[..certify_key_resp.cert_size as usize])
.unwrap();
assert!(cert.subject_alternative_name().unwrap().is_none());
// populate DMTF otherName
let dmtf_device_info_utf8 = "ChipsAlliance:Caliptra:0123456789";
let dmtf_device_info_bytes = dmtf_device_info_utf8.as_bytes();
let mut dmtf_device_info = [0u8; AddSubjectAltNameReq::MAX_DEVICE_INFO_LEN];
dmtf_device_info[..dmtf_device_info_bytes.len()].copy_from_slice(dmtf_device_info_bytes);
let mut cmd = MailboxReq::AddSubjectAltName(AddSubjectAltNameReq {
hdr: MailboxReqHeader { chksum: 0 },
dmtf_device_info_size: dmtf_device_info_bytes.len() as u32,
dmtf_device_info,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::ADD_SUBJECT_ALT_NAME),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
// Check that otherName extension is not present if not requested in input flags
let mut cmd = MailboxReq::CertifyKeyExtended(CertifyKeyExtendedReq {
hdr: MailboxReqHeader { chksum: 0 },
certify_key_req: certify_key_cmd.as_bytes().try_into().unwrap(),
flags: CertifyKeyExtendedFlags::empty(),
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CERTIFY_KEY_EXTENDED),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let certify_key_extended_resp =
CertifyKeyExtendedResp::read_from_bytes(resp.as_slice()).unwrap();
let certify_key_resp =
CertifyKeyResp::try_read_from_bytes(&certify_key_extended_resp.certify_key_resp[..])
.unwrap();
let (_, cert) =
X509Certificate::from_der(&certify_key_resp.cert[..certify_key_resp.cert_size as usize])
.unwrap();
assert!(cert.subject_alternative_name().unwrap().is_none());
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_authorize_and_stash.rs | runtime/tests/runtime_integration_tests/test_authorize_and_stash.rs | // Licensed under the Apache-2.0 license
use crate::common::{run_rt_test, RuntimeTestArgs};
use crate::test_set_auth_manifest::{
create_auth_manifest, create_auth_manifest_with_metadata, AuthManifestBuilderCfg,
};
use crate::test_update_reset::update_fw;
use caliptra_api::mailbox::{MailboxRespHeader, VerifyAuthManifestReq};
use caliptra_api::SocManager;
use caliptra_auth_man_types::{
Addr64, AuthManifestFlags, AuthManifestImageMetadata, AuthorizationManifest, ImageMetadataFlags,
};
use caliptra_builder::firmware::APP_WITH_UART;
use caliptra_builder::{firmware::FMC_WITH_UART, ImageOptions};
use caliptra_common::mailbox_api::{
AuthorizeAndStashReq, AuthorizeAndStashResp, CommandId, ImageHashSource, MailboxReq,
MailboxReqHeader, SetAuthManifestReq,
};
use caliptra_hw_model::{DefaultHwModel, HwModel};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::RtBootStatus;
use caliptra_runtime::{IMAGE_AUTHORIZED, IMAGE_HASH_MISMATCH, IMAGE_NOT_AUTHORIZED};
use sha2::{Digest, Sha384};
use zerocopy::{FromBytes, IntoBytes};
pub const IMAGE_DIGEST1: [u8; 48] = [
0x38, 0xB0, 0x60, 0xA7, 0x51, 0xAC, 0x96, 0x38, 0x4C, 0xD9, 0x32, 0x7E, 0xB1, 0xB1, 0xE3, 0x6A,
0x21, 0xFD, 0xB7, 0x11, 0x14, 0xBE, 0x07, 0x43, 0x4C, 0x0C, 0xC7, 0xBF, 0x63, 0xF6, 0xE1, 0xDA,
0x27, 0x4E, 0xDE, 0xBF, 0xE7, 0x6F, 0x65, 0xFB, 0xD5, 0x1A, 0xD2, 0xF1, 0x48, 0x98, 0xB9, 0x5B,
];
pub const IMAGE_DIGEST_BAD: [u8; 48] = [
0x39, 0xB0, 0x60, 0xA7, 0x51, 0xAC, 0x96, 0x38, 0x4C, 0xD9, 0x32, 0x7E, 0xB1, 0xB1, 0xE3, 0x6A,
0x21, 0xFD, 0xB7, 0x11, 0x14, 0xBE, 0x07, 0x43, 0x4C, 0x0C, 0xC7, 0xBF, 0x63, 0xF6, 0xE1, 0xDA,
0x27, 0x4E, 0xDE, 0xBF, 0xE7, 0x6F, 0x65, 0xFB, 0xD5, 0x1A, 0xD2, 0xF1, 0x48, 0x98, 0xB9, 0x5B,
];
pub const FW_ID_1: [u8; 4] = [0x01, 0x00, 0x00, 0x00];
pub const FW_ID_2: [u8; 4] = [0x02, 0x00, 0x00, 0x00];
pub const FW_ID_BAD: [u8; 4] = [0xDE, 0xED, 0xBE, 0xEF];
#[cfg(feature = "fpga_subsystem")]
pub const TEST_SRAM_SIZE: usize = 0x1000;
#[cfg(feature = "fpga_subsystem")]
const MCI_BASE: u32 = 0xA8000000;
#[cfg(feature = "fpga_subsystem")]
const MCU_MBOX_SRAM_BASE: u32 = MCI_BASE + 0x400000;
#[cfg(feature = "fpga_subsystem")]
pub const TEST_SRAM_BASE: Addr64 = Addr64 {
lo: MCU_MBOX_SRAM_BASE,
hi: 0x0000_0000,
};
#[cfg(not(feature = "fpga_subsystem"))]
pub const TEST_SRAM_BASE: Addr64 = Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
};
pub fn set_auth_manifest(auth_manifest: Option<AuthorizationManifest>) -> DefaultHwModel {
let runtime_args = RuntimeTestArgs {
test_image_options: Some(ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
}),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let auth_manifest = if let Some(auth_manifest) = auth_manifest {
auth_manifest
} else {
create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::LMS,
svn: 1,
})
};
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
model
}
pub fn set_auth_manifest_with_test_sram(
auth_manifest: Option<AuthorizationManifest>,
test_sram: &[u8],
mcu_image: &[u8],
) -> DefaultHwModel {
let runtime_args = RuntimeTestArgs {
test_image_options: Some(ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
}),
test_sram: Some(test_sram),
soc_manifest: Some(
auth_manifest
.as_ref()
.map(|m| m.as_bytes())
.unwrap_or_default(),
),
mcu_fw_image: Some(mcu_image),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let auth_manifest = if let Some(auth_manifest) = auth_manifest {
auth_manifest
} else {
create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::LMS,
svn: 1,
})
};
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
model
}
#[test]
fn test_authorize_and_stash_cmd_deny_authorization() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
fw_id: FW_ID_BAD,
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::ref_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
// create a new fw image with the runtime replaced by the mbox responder
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options,
)
.unwrap()
.to_bytes()
.unwrap();
// trigger an update reset so we can use commands in mbox responder
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let valid_pauser_hash_resp = model.mailbox_execute(0x2000_0000, &[]).unwrap().unwrap();
let valid_pauser_hash: [u8; 48] = valid_pauser_hash_resp.as_bytes().try_into().unwrap();
// We don't expect the image_digest to be part of the stash
let mut hasher = Sha384::new();
hasher.update(rt_journey_pcr);
hasher.update(valid_pauser_hash);
let expected_measurement_hash = hasher.finalize();
let dpe_measurement_hash = model.mailbox_execute(0x3000_0000, &[]).unwrap().unwrap();
assert_eq!(expected_measurement_hash.as_bytes(), dpe_measurement_hash);
}
#[test]
fn test_authorize_and_stash_cmd_success() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_1,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
// create a new fw image with the runtime replaced by the mbox responder
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options,
)
.unwrap()
.to_bytes()
.unwrap();
// trigger an update reset so we can use commands in mbox responder
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let valid_pauser_hash_resp = model.mailbox_execute(0x2000_0000, &[]).unwrap().unwrap();
let valid_pauser_hash: [u8; 48] = valid_pauser_hash_resp.as_bytes().try_into().unwrap();
// hash expected DPE measurements in order to check that stashed measurement was added to DPE
let mut hasher = Sha384::new();
hasher.update(rt_journey_pcr);
hasher.update(valid_pauser_hash);
hasher.update(IMAGE_DIGEST1);
let expected_measurement_hash = hasher.finalize();
let dpe_measurement_hash = model.mailbox_execute(0x3000_0000, &[]).unwrap().unwrap();
assert_eq!(expected_measurement_hash.as_bytes(), dpe_measurement_hash);
}
#[test]
fn test_authorize_and_stash_cmd_deny_authorization_no_hash_or_id() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
}
#[test]
fn test_authorize_and_stash_cmd_deny_authorization_wrong_id_no_hash() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
}
#[test]
fn test_authorize_and_stash_cmd_deny_authorization_wrong_hash() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_1,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_HASH_MISMATCH
);
}
#[test]
fn test_authorize_and_stash_cmd_success_skip_auth() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_2,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
#[test]
fn test_authorize_and_stash_fwid_0() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_0: [u8; 4] = [0x00, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 0,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
#[test]
fn test_authorize_and_stash_fwid_127() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_127: [u8; 4] = [0x7F, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 127,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_127,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
#[test]
fn test_authorize_and_stash_cmd_deny_second_bad_hash() {
{
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_1,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp =
AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
{
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 1,
flags: flags.0,
digest: IMAGE_DIGEST_BAD,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_1,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp =
AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_HASH_MISMATCH
);
}
}
#[test]
fn test_authorize_and_stash_after_update_reset() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_0: [u8; 4] = [0x00, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 0,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
// Trigger an update reset.
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
update_fw(&mut model, &APP_WITH_UART, image_options);
// Re-authorize the image.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
#[test]
fn test_authorize_and_stash_after_update_reset_unauthorized_fw_id() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_127: [u8; 4] = [0x7F, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 0,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_127,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
// Trigger an update reset.
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
update_fw(&mut model, &APP_WITH_UART, image_options);
// Attempt Authorization with a unauthorized fw id.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_127,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
}
#[test]
fn test_authorize_and_stash_after_update_reset_bad_hash() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_0: [u8; 4] = [0x00, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 0,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_HASH_MISMATCH
);
// Trigger an update reset.
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
update_fw(&mut model, &APP_WITH_UART, image_options);
// Attempt Authorization with a bad image hash.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_HASH_MISMATCH
);
}
#[test]
fn test_authorize_and_stash_after_update_reset_skip_auth() {
let mut model = set_auth_manifest(None);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_2,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
// Trigger an update reset.
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
update_fw(&mut model, &APP_WITH_UART, image_options);
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_2,
measurement: IMAGE_DIGEST_BAD,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
#[test]
fn test_authorize_and_stash_after_update_reset_multiple_set_manifest() {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::InRequest as u32);
const FW_ID_0: [u8; 4] = [0x00, 0x00, 0x00, 0x00];
const FW_ID_127: [u8; 4] = [0x7F, 0x00, 0x00, 0x00];
let image_metadata = vec![AuthManifestImageMetadata {
fw_id: 0,
flags: flags.0,
digest: IMAGE_DIGEST1,
..Default::default()
}];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
// Valid authorization.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
// Invalid authorization.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_127,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
authorize_and_stash_resp.auth_req_result,
IMAGE_NOT_AUTHORIZED
);
// Trigger an update reset.
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
update_fw(&mut model, &APP_WITH_UART, image_options);
//
// Check again
//
// Valid authorization.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_0,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp = AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
// Invalid authorization.
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_127,
measurement: IMAGE_DIGEST1,
source: ImageHashSource::InRequest as u32,
flags: 0, // Don't skip stash
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_cryptographic_mailbox.rs | runtime/tests/runtime_integration_tests/test_cryptographic_mailbox.rs | // Licensed under the Apache-2.0 license
use std::collections::VecDeque;
use crate::common::{assert_error, run_rt_test, start_rt_test_pqc_model, RuntimeTestArgs};
use aes::Aes256;
use aes_gcm::{aead::AeadMutInPlace, Key};
use caliptra_api::mailbox::{
populate_checksum, CmAesDecryptInitReq, CmAesDecryptUpdateReq, CmAesEncryptInitReq,
CmAesEncryptInitResp, CmAesEncryptInitRespHeader, CmAesEncryptUpdateReq,
CmAesGcmDecryptFinalReq, CmAesGcmDecryptFinalResp, CmAesGcmDecryptFinalRespHeader,
CmAesGcmDecryptInitReq, CmAesGcmDecryptInitResp, CmAesGcmDecryptUpdateReq,
CmAesGcmDecryptUpdateResp, CmAesGcmDecryptUpdateRespHeader, CmAesGcmEncryptFinalReq,
CmAesGcmEncryptFinalResp, CmAesGcmEncryptFinalRespHeader, CmAesGcmEncryptInitReq,
CmAesGcmEncryptInitResp, CmAesGcmEncryptUpdateReq, CmAesGcmEncryptUpdateResp,
CmAesGcmEncryptUpdateRespHeader, CmAesGcmSpdmDecryptInitReq, CmAesGcmSpdmDecryptInitResp,
CmAesGcmSpdmEncryptInitReq, CmAesGcmSpdmEncryptInitResp, CmAesMode, CmAesResp, CmAesRespHeader,
CmDeleteReq, CmDeriveStableKeyReq, CmDeriveStableKeyResp, CmEcdhFinishReq, CmEcdhFinishResp,
CmEcdhGenerateReq, CmEcdhGenerateResp, CmEcdsaPublicKeyReq, CmEcdsaPublicKeyResp,
CmEcdsaSignReq, CmEcdsaSignResp, CmEcdsaVerifyReq, CmHashAlgorithm, CmHkdfExpandReq,
CmHkdfExpandResp, CmHkdfExtractReq, CmHkdfExtractResp, CmHmacKdfCounterReq,
CmHmacKdfCounterResp, CmHmacReq, CmHmacResp, CmImportReq, CmImportResp, CmKeyUsage,
CmMldsaPublicKeyReq, CmMldsaPublicKeyResp, CmMldsaSignReq, CmMldsaSignResp, CmMldsaVerifyReq,
CmRandomGenerateReq, CmRandomGenerateResp, CmRandomStirReq, CmShaFinalReq, CmShaFinalResp,
CmShaInitReq, CmShaInitResp, CmShaUpdateReq, CmStableKeyType, CmStatusResp, Cmk, CommandId,
MailboxReq, MailboxReqHeader, MailboxRespHeader, MailboxRespHeaderVarSize, ResponseVarSize,
CMB_ECDH_EXCHANGE_DATA_MAX_SIZE, CMK_SIZE_BYTES, MAX_CMB_DATA_SIZE,
};
use caliptra_api::SocManager;
use caliptra_drivers::AES_BLOCK_SIZE_BYTES;
use caliptra_hw_model::{DefaultHwModel, HwModel, InitParams, SubsystemInitParams, TrngMode};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::RtBootStatus;
use cbc::cipher::BlockEncryptMut;
use cipher::{KeyIvInit, StreamCipherCore};
use fips204::ml_dsa_87;
use fips204::traits::Signer;
use hkdf::Hkdf;
use hmac::{Hmac, Mac};
use p384::ecdsa::signature::hazmat::PrehashSigner;
use p384::ecdsa::{Signature, SigningKey};
use rand::prelude::*;
use rand::rngs::StdRng;
use rand::{CryptoRng, RngCore};
use sha2::{Digest, Sha384, Sha512};
use zerocopy::{transmute, FromBytes, IntoBytes};
#[cfg(feature = "fpga_subsystem")]
const HW_MODEL_MODES_SUBSYSTEM: [bool; 1] = [true];
#[cfg(feature = "fpga_realtime")]
const HW_MODEL_MODES_SUBSYSTEM: [bool; 1] = [false];
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
const HW_MODEL_MODES_SUBSYSTEM: [bool; 2] = [false, true];
#[test]
fn test_status() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::CM_STATUS), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::CM_STATUS), payload.as_bytes())
.unwrap()
.expect("We should have received a response");
let cm_resp = CmStatusResp::ref_from_bytes(resp.as_slice()).unwrap();
assert_eq!(cm_resp.used_usage_storage, 0);
assert_eq!(cm_resp.total_usage_storage, 256);
}
#[test]
fn test_import() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// check too large of an input
let mut cm_import_cmd = MailboxReq::CmImport(CmImportReq {
hdr: MailboxReqHeader { chksum: 0 },
key_usage: CmKeyUsage::Aes.into(),
input_size: 1000,
input: [0xaa; 64],
});
assert_eq!(
cm_import_cmd.populate_chksum().unwrap_err(),
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE
);
// wrong size
let mut cm_import_cmd = MailboxReq::CmImport(CmImportReq {
hdr: MailboxReqHeader { chksum: 0 },
key_usage: CmKeyUsage::Aes.into(),
input_size: 64,
input: [0xaa; 64],
});
cm_import_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CM_IMPORT),
cm_import_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_CMB_INVALID_KEY_USAGE_AND_SIZE,
resp,
);
// AES key import
let mut cm_import_cmd = MailboxReq::CmImport(CmImportReq {
hdr: MailboxReqHeader { chksum: 0 },
key_usage: CmKeyUsage::Aes.into(),
input_size: 32,
input: [0xaa; 64],
});
cm_import_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CM_IMPORT),
cm_import_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let cm_import_resp = CmImportResp::ref_from_bytes(resp.as_slice()).unwrap();
let cmk = cm_import_resp.cmk.as_bytes();
assert_eq!(CMK_SIZE_BYTES, cmk.len());
assert!(!cmk.iter().all(|&x| x == 0));
assert_eq!(
cm_import_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::CM_STATUS), &[]),
};
let status_resp = model
.mailbox_execute(u32::from(CommandId::CM_STATUS), payload.as_bytes())
.unwrap()
.expect("We should have received a response");
let cm_resp = CmStatusResp::ref_from_bytes(status_resp.as_slice()).unwrap();
assert_eq!(cm_resp.used_usage_storage, 1);
assert_eq!(cm_resp.total_usage_storage, 256);
}
#[test]
fn test_import_full() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// AES key import
let mut cm_import_cmd = MailboxReq::CmImport(CmImportReq {
hdr: MailboxReqHeader { chksum: 0 },
key_usage: CmKeyUsage::Aes.into(),
input_size: 32,
input: [0xaa; 64],
});
cm_import_cmd.populate_chksum().unwrap();
for _ in 0..256 {
model
.mailbox_execute(
u32::from(CommandId::CM_IMPORT),
cm_import_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
}
let err = model
.mailbox_execute(
u32::from(CommandId::CM_IMPORT),
cm_import_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_CMB_KEY_USAGE_STORAGE_FULL,
err,
);
let cm_resp = status(&mut model);
assert_eq!(cm_resp.used_usage_storage, 256);
assert_eq!(cm_resp.total_usage_storage, 256);
}
// this test is very slow so we only test it manually (on an FPGA, preferably)
#[ignore]
// Test that we can import more than 2^24 keys as long as we delete them occasionally.
#[test]
fn test_import_wraparound() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let raw_key = [0xaa; 32];
let mut keys = VecDeque::new();
for _ in 0..((1 << 24) + 1000) {
let cmk = import_key(&mut model, &raw_key, CmKeyUsage::Aes);
keys.push_back(cmk);
if keys.len() >= 256 {
delete_key(&mut model, &keys.pop_front().unwrap());
}
}
}
fn status(model: &mut DefaultHwModel) -> CmStatusResp {
let mut req = MailboxReq::CmStatus(MailboxReqHeader::default());
req.populate_chksum().unwrap();
let req = req.as_bytes().unwrap();
let status_resp = model
.mailbox_execute(u32::from(CommandId::CM_STATUS), req)
.unwrap()
.expect("We should have received a response");
CmStatusResp::read_from_bytes(status_resp.as_slice()).unwrap()
}
fn delete_key(model: &mut DefaultHwModel, cmk: &Cmk) {
let mut req = MailboxReq::CmDelete(CmDeleteReq {
hdr: MailboxReqHeader::default(),
cmk: cmk.clone(),
});
req.populate_chksum().unwrap();
let req = req.as_bytes().unwrap();
model
.mailbox_execute(u32::from(CommandId::CM_DELETE), req)
.unwrap()
.expect("We should have received a response");
}
#[test]
fn test_delete() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let cmk = import_key(&mut model, &[0xaa; 32], CmKeyUsage::Aes);
let status_resp = status(&mut model);
assert_eq!(status_resp.used_usage_storage, 1);
assert_eq!(status_resp.total_usage_storage, 256);
delete_key(&mut model, &cmk);
let status_resp = status(&mut model);
assert_eq!(status_resp.used_usage_storage, 0);
assert_eq!(status_resp.total_usage_storage, 256);
}
#[test]
fn test_clear() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut req = MailboxReq::CmClear(MailboxReqHeader::default());
req.populate_chksum().unwrap();
let req = req.as_bytes().unwrap();
let raw_key = [0xaa; 32];
let mut keys = VecDeque::new();
for _ in 0..256 {
let cmk = import_key(&mut model, &raw_key, CmKeyUsage::Aes);
keys.push_back(cmk);
}
let status_resp = status(&mut model);
assert_eq!(status_resp.used_usage_storage, 256);
assert_eq!(status_resp.total_usage_storage, 256);
model
.mailbox_execute(u32::from(CommandId::CM_CLEAR), req)
.unwrap()
.expect("We should have received a response");
let status_resp = status(&mut model);
assert_eq!(status_resp.used_usage_storage, 0);
assert_eq!(status_resp.total_usage_storage, 256);
}
#[test]
fn test_sha384_simple() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let input_data = "a".repeat(129);
let input_data = input_data.as_bytes();
// Simple case
let mut req = CmShaInitReq {
hash_algorithm: 1, // SHA384
input_size: input_data.len() as u32,
..Default::default()
};
req.input[..input_data.len()].copy_from_slice(input_data);
let mut init = MailboxReq::CmShaInit(req);
init.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_INIT), init.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let resp = CmShaInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
let req = CmShaFinalReq {
context: resp.context,
..Default::default()
};
let mut fin = MailboxReq::CmShaFinal(req);
fin.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_FINAL), fin.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let mut expected_resp = CmShaFinalResp::default();
expected_resp.hdr.data_len = 48;
let mut hasher = Sha384::new();
hasher.update(input_data);
let expected_hash = hasher.finalize();
expected_resp.hash[..48].copy_from_slice(expected_hash.as_bytes());
populate_checksum(expected_resp.as_bytes_partial_mut().unwrap());
let expected_bytes = expected_resp.as_bytes_partial().unwrap();
assert_eq!(expected_bytes, resp_bytes);
}
#[test]
fn test_sha_partial_update() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// check sha384 and sha512
for sha in [1, 2] {
let input_str = "a".repeat(2048);
let input_copy = input_str.clone();
let original_input_data = input_copy.as_bytes();
let mut input_data = input_str.as_bytes().to_vec();
let mut input_data = input_data.as_mut_slice();
let split = 4;
let initial = 1024;
let mut req: CmShaInitReq = CmShaInitReq {
hash_algorithm: sha,
input_size: initial as u32,
..Default::default()
};
req.input[..initial].copy_from_slice(&input_data[..initial]);
input_data = &mut input_data[initial..];
let mut init = MailboxReq::CmShaInit(req);
init.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_INIT), init.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let mut resp = CmShaInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
let mut resp_bytes: Vec<u8>;
while input_data.len() > split {
let mut req = CmShaUpdateReq {
input_size: split as u32,
context: resp.context,
..Default::default()
};
req.input[..split].copy_from_slice(&input_data[..split]);
let mut update = MailboxReq::CmShaUpdate(req);
update.populate_chksum().unwrap();
resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_SHA_UPDATE),
update.as_bytes().unwrap(),
)
.unwrap()
.expect("Should have gotten a context");
resp = CmShaInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
input_data = &mut input_data[split..];
}
let mut req = CmShaFinalReq {
input_size: input_data.len() as u32,
context: resp.context,
..Default::default()
};
req.input[..input_data.len()].copy_from_slice(input_data);
let mut fin = MailboxReq::CmShaFinal(req);
fin.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_FINAL), fin.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let mut expected_resp = CmShaFinalResp::default();
if sha == 1 {
let mut hasher = Sha384::new();
hasher.update(original_input_data);
let expected_hash = hasher.finalize();
expected_resp.hash[..48].copy_from_slice(expected_hash.as_bytes());
expected_resp.hdr.data_len = 48;
} else {
let mut hasher = Sha512::new();
hasher.update(original_input_data);
let expected_hash = hasher.finalize();
expected_resp.hash.copy_from_slice(expected_hash.as_bytes());
expected_resp.hdr.data_len = 64;
};
populate_checksum(expected_resp.as_bytes_partial_mut().unwrap());
let expected_bytes = expected_resp.as_bytes_partial().unwrap();
assert_eq!(expected_bytes, resp_bytes);
}
}
#[test]
fn test_sha_many() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// check sha384 and sha512
for sha in [1, 2] {
// 467 is a prime so should exercise different edge cases in sizes but not take too long
for i in (0..MAX_CMB_DATA_SIZE * 4).step_by(467) {
let input_str = "a".repeat(i);
let input_copy = input_str.clone();
let original_input_data = input_copy.as_bytes();
let mut input_data = input_str.as_bytes().to_vec();
let mut input_data = input_data.as_mut_slice();
let process = input_data.len().min(MAX_CMB_DATA_SIZE);
let mut req: CmShaInitReq = CmShaInitReq {
hash_algorithm: sha,
input_size: process as u32,
..Default::default()
};
req.input[..process].copy_from_slice(&input_data[..process]);
input_data = &mut input_data[process..];
let mut init = MailboxReq::CmShaInit(req);
init.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_INIT), init.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let mut resp = CmShaInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
let mut resp_bytes: Vec<u8>;
while input_data.len() > MAX_CMB_DATA_SIZE {
let mut req = CmShaUpdateReq {
input_size: MAX_CMB_DATA_SIZE as u32,
context: resp.context,
..Default::default()
};
req.input.copy_from_slice(&input_data[..MAX_CMB_DATA_SIZE]);
let mut update = MailboxReq::CmShaUpdate(req);
update.populate_chksum().unwrap();
resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_SHA_UPDATE),
update.as_bytes().unwrap(),
)
.unwrap()
.expect("Should have gotten a context");
resp = CmShaInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
input_data = &mut input_data[MAX_CMB_DATA_SIZE..];
}
let mut req = CmShaFinalReq {
input_size: input_data.len() as u32,
context: resp.context,
..Default::default()
};
req.input[..input_data.len()].copy_from_slice(input_data);
let mut fin = MailboxReq::CmShaFinal(req);
fin.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::CM_SHA_FINAL), fin.as_bytes().unwrap())
.unwrap()
.expect("Should have gotten a context");
let mut expected_resp = CmShaFinalResp::default();
if sha == 1 {
let mut hasher = Sha384::new();
hasher.update(original_input_data);
let expected_hash = hasher.finalize();
expected_resp.hash[..48].copy_from_slice(expected_hash.as_bytes());
expected_resp.hdr.data_len = 48;
} else {
let mut hasher = Sha512::new();
hasher.update(original_input_data);
let expected_hash = hasher.finalize();
expected_resp.hash.copy_from_slice(expected_hash.as_bytes());
expected_resp.hdr.data_len = 64;
};
populate_checksum(expected_resp.as_bytes_partial_mut().unwrap());
let expected_bytes = expected_resp.as_bytes_partial().unwrap();
assert_eq!(expected_bytes, resp_bytes);
}
}
}
#[test]
fn test_random_generate() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// check too large of an input
let mut cm_random_generate = MailboxReq::CmRandomGenerate(CmRandomGenerateReq {
hdr: MailboxReqHeader::default(),
size: u32::MAX,
});
cm_random_generate.populate_chksum().unwrap();
let err = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_GENERATE),
cm_random_generate.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS,
err,
);
// 0 bytes
let mut cm_random_generate = MailboxReq::CmRandomGenerate(CmRandomGenerateReq {
hdr: MailboxReqHeader::default(),
size: 0,
});
cm_random_generate.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_GENERATE),
cm_random_generate.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut resp = CmRandomGenerateResp::default();
const VAR_HEADER_SIZE: usize = size_of::<MailboxRespHeaderVarSize>();
resp.hdr = MailboxRespHeaderVarSize::read_from_bytes(&resp_bytes[..VAR_HEADER_SIZE]).unwrap();
assert_eq!(resp.hdr.data_len, 0);
assert!(resp_bytes[VAR_HEADER_SIZE..].iter().all(|&x| x == 0));
// 1 byte
let mut cm_random_generate = MailboxReq::CmRandomGenerate(CmRandomGenerateReq {
hdr: MailboxReqHeader::default(),
size: 1,
});
cm_random_generate.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_GENERATE),
cm_random_generate.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut resp = CmRandomGenerateResp {
hdr: MailboxRespHeaderVarSize::read_from_bytes(&resp_bytes[..VAR_HEADER_SIZE]).unwrap(),
..Default::default()
};
let len = resp.hdr.data_len as usize;
assert_eq!(len, 1);
resp.data[..len].copy_from_slice(&resp_bytes[VAR_HEADER_SIZE..VAR_HEADER_SIZE + len]);
// We can't check if it is non-zero because it will randomly be 0 sometimes.
for req_len in [47usize, 48, 1044] {
let mut cm_random_generate = MailboxReq::CmRandomGenerate(CmRandomGenerateReq {
hdr: MailboxReqHeader::default(),
size: req_len as u32,
});
cm_random_generate.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_GENERATE),
cm_random_generate.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut resp = CmRandomGenerateResp {
hdr: MailboxRespHeaderVarSize::read_from_bytes(&resp_bytes[..VAR_HEADER_SIZE]).unwrap(),
..Default::default()
};
let len = resp.hdr.data_len as usize;
assert_eq!(len, req_len);
resp.data[..len].copy_from_slice(&resp_bytes[VAR_HEADER_SIZE..VAR_HEADER_SIZE + len]);
assert!(
resp.data[..len]
.iter()
.copied()
.reduce(|a, b| (a | b))
.unwrap()
!= 0
);
}
}
#[test]
fn test_random_stir_itrng() {
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let subsystem_mode = cfg!(feature = "fpga_subsystem");
let mut model = run_rt_test(RuntimeTestArgs {
init_params: Some(InitParams {
rom: &rom,
trng_mode: Some(TrngMode::Internal),
subsystem_mode,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: subsystem_mode,
..Default::default()
},
..Default::default()
}),
..Default::default()
});
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// check too large of an input
let mut cm_random_stir = MailboxReq::CmRandomStir(CmRandomStirReq {
hdr: MailboxReqHeader::default(),
input_size: u32::MAX,
..Default::default()
});
assert_eq!(
cm_random_stir.populate_chksum().unwrap_err(),
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE
);
// 0 bytes
let mut cm_random_stir = MailboxReq::CmRandomStir(CmRandomStirReq {
hdr: MailboxReqHeader::default(),
input_size: 0,
..Default::default()
});
cm_random_stir.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_STIR),
cm_random_stir.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
// There's nothing we can really check other than success.
let _ =
MailboxRespHeader::read_from_bytes(&resp_bytes[..size_of::<MailboxRespHeader>()]).unwrap();
// 1 byte
let mut cm_random_stir = MailboxReq::CmRandomStir(CmRandomStirReq {
hdr: MailboxReqHeader::default(),
input_size: 1,
input: [0xff; MAX_CMB_DATA_SIZE],
});
cm_random_stir.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_STIR),
cm_random_stir.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
// There's nothing we can really check other than success.
let _ =
MailboxRespHeader::read_from_bytes(&resp_bytes[..size_of::<MailboxRespHeader>()]).unwrap();
for req_len in [47usize, 48, 1044] {
let mut cm_random_stir = MailboxReq::CmRandomStir(CmRandomStirReq {
hdr: MailboxReqHeader::default(),
input_size: req_len as u32,
input: [0xff; MAX_CMB_DATA_SIZE],
});
cm_random_stir.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_STIR),
cm_random_stir.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
// There's nothing we can really check other than success.
let _ = MailboxRespHeader::read_from_bytes(&resp_bytes[..size_of::<MailboxRespHeader>()])
.unwrap();
}
}
#[cfg_attr(
any(
feature = "fpga_realtime",
feature = "fpga_subsystem",
feature = "itrng"
),
ignore
)] // FPGA always has an itrng
#[test]
fn test_random_stir_etrng_not_supported() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cm_random_stir = MailboxReq::CmRandomStir(CmRandomStirReq {
hdr: MailboxReqHeader::default(),
input_size: 0,
..Default::default()
});
cm_random_stir.populate_chksum().unwrap();
let err = model
.mailbox_execute(
u32::from(CommandId::CM_RANDOM_STIR),
cm_random_stir.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::DRIVER_TRNG_UPDATE_NOT_SUPPORTED,
err,
);
}
#[test]
fn test_aes_gcm_edge_cases() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let cmk = import_key(&mut model, &[0xaa; 32], CmKeyUsage::Aes);
// check too large of an input
let mut cm_aes_encrypt_init = MailboxReq::CmAesGcmEncryptInit(CmAesGcmEncryptInitReq {
hdr: MailboxReqHeader::default(),
flags: 0,
cmk,
aad_size: u32::MAX,
aad: [0; MAX_CMB_DATA_SIZE],
});
cm_aes_encrypt_init
.populate_chksum()
.expect_err("Should have failed");
// check tag too large or small
let mut cm_aes_decrypt_final = MailboxReq::CmAesGcmDecryptFinal(CmAesGcmDecryptFinalReq {
tag_len: 7,
..Default::default()
});
cm_aes_decrypt_final.populate_chksum().unwrap();
let err = model
.mailbox_execute(
u32::from(CommandId::CM_AES_GCM_DECRYPT_FINAL),
cm_aes_decrypt_final.as_bytes().unwrap(),
)
.expect_err("Should have failed");
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS,
err,
);
let mut cm_aes_decrypt_final = MailboxReq::CmAesGcmDecryptFinal(CmAesGcmDecryptFinalReq {
tag_len: 17,
..Default::default()
});
cm_aes_decrypt_final.populate_chksum().unwrap();
let err = model
.mailbox_execute(
u32::from(CommandId::CM_AES_GCM_DECRYPT_FINAL),
cm_aes_decrypt_final.as_bytes().unwrap(),
)
.expect_err("Should have failed");
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS,
err,
);
// TODO: check the rest of the edge cases
}
// Check a simple encryption with 4 bytes of data.
#[test]
fn test_aes_gcm_simple() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let key = [0xaa; 32];
let cmk = import_key(&mut model, &key, CmKeyUsage::Aes);
let mut cm_aes_encrypt_init = MailboxReq::CmAesGcmEncryptInit(CmAesGcmEncryptInitReq {
hdr: MailboxReqHeader::default(),
flags: 0,
cmk,
aad_size: 0,
aad: [0; MAX_CMB_DATA_SIZE],
});
cm_aes_encrypt_init.populate_chksum().unwrap();
let resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_AES_GCM_ENCRYPT_INIT),
cm_aes_encrypt_init.as_bytes().unwrap(),
)
.expect("Should have succeeded")
.unwrap();
let resp = CmAesGcmEncryptInitResp::ref_from_bytes(resp_bytes.as_slice()).unwrap();
assert_eq!(
resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let mut cm_aes_encrypt_final = MailboxReq::CmAesGcmEncryptFinal(CmAesGcmEncryptFinalReq {
hdr: MailboxReqHeader::default(),
context: resp.context,
plaintext_size: 4,
plaintext: [1; MAX_CMB_DATA_SIZE],
});
cm_aes_encrypt_final.populate_chksum().unwrap();
let final_resp_bytes = model
.mailbox_execute(
u32::from(CommandId::CM_AES_GCM_ENCRYPT_FINAL),
cm_aes_encrypt_final.as_bytes().unwrap(),
)
.expect("Should have succeeded")
.unwrap();
const FINAL_HEADER_SIZE: usize = size_of::<CmAesGcmEncryptFinalRespHeader>();
let mut final_resp = CmAesGcmEncryptFinalResp {
hdr: CmAesGcmEncryptFinalRespHeader::read_from_bytes(
&final_resp_bytes[..FINAL_HEADER_SIZE],
)
.unwrap(),
..Default::default()
};
assert_eq!(
final_resp.hdr.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let len = final_resp.hdr.ciphertext_size as usize;
assert_eq!(len, 4);
final_resp.ciphertext[..len]
.copy_from_slice(&final_resp_bytes[FINAL_HEADER_SIZE..FINAL_HEADER_SIZE + len]);
let ciphertext = &final_resp.ciphertext[..final_resp.hdr.ciphertext_size as usize];
let iv = &resp.iv;
let aad = &[];
let plaintext = &[1, 1, 1, 1];
let (rtag, rciphertext) = rustcrypto_gcm_encrypt(&key, iv.as_bytes(), aad, plaintext);
assert_eq!(ciphertext, &rciphertext);
assert_eq!(final_resp.hdr.tag.as_bytes(), rtag);
}
// Random encrypt and decrypt GCM stress test.
#[test]
fn test_aes_gcm_random_encrypt_decrypt() {
let seed_bytes = [1u8; 32];
let mut seeded_rng = StdRng::from_seed(seed_bytes);
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
const KEYS: usize = 16;
let mut keys = vec![];
let mut cmks = vec![];
for _ in 0..KEYS {
let mut key = [0u8; 32];
seeded_rng.fill_bytes(&mut key);
keys.push(key);
cmks.push(import_key(&mut model, &key, CmKeyUsage::Aes));
}
for _ in 0..100 {
let key_idx = seeded_rng.gen_range(0..KEYS);
let len = seeded_rng.gen_range(0..MAX_CMB_DATA_SIZE * 3);
let mut plaintext = vec![0u8; len];
seeded_rng.fill_bytes(&mut plaintext);
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_debug_unlock.rs | runtime/tests/runtime_integration_tests/test_debug_unlock.rs | // Licensed under the Apache-2.0 license
use crate::common::{run_rt_test, RuntimeTestArgs};
use crate::test_set_auth_manifest::create_auth_manifest_with_metadata;
use caliptra_api::{
mailbox::{
CommandId, MailboxReqHeader, ProductionAuthDebugUnlockChallenge,
ProductionAuthDebugUnlockReq, ProductionAuthDebugUnlockToken,
},
SocManager,
};
use caliptra_auth_man_types::{AuthManifestImageMetadata, ImageMetadataFlags};
use caliptra_common::{
memory_layout::{ROM_ORG, ROM_SIZE, ROM_STACK_ORG, ROM_STACK_SIZE, STACK_ORG, STACK_SIZE},
FMC_ORG, FMC_SIZE, RUNTIME_ORG, RUNTIME_SIZE,
};
use caliptra_drivers::CaliptraError;
use caliptra_hw_model::{
CodeRange, DeviceLifecycle, HwModel, ImageInfo, InitParams, ModelError, SecurityState,
StackInfo, StackRange, SubsystemInitParams,
};
use caliptra_image_crypto::OsslCrypto as Crypto;
use caliptra_image_gen::{from_hw_format, ImageGeneratorCrypto};
use fips204::traits::{SerDes, Signer};
use p384::ecdsa::VerifyingKey;
use rand::{rngs::StdRng, SeedableRng};
use sha2::Digest;
use zerocopy::{FromBytes, IntoBytes};
fn u8_to_u32_be(input: &[u8]) -> Vec<u32> {
input
.chunks(4)
.map(|chunk| {
let mut array = [0u8; 4];
array.copy_from_slice(chunk);
u32::from_be_bytes(array)
})
.collect()
}
fn u8_to_u32_le(input: &[u8]) -> Vec<u32> {
input
.chunks(4)
.map(|chunk| {
let mut array = [0u8; 4];
array.copy_from_slice(chunk);
u32::from_le_bytes(array)
})
.collect()
}
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_dbg_unlock_prod_success() {
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, signing_mldsa_key) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let unlock_level = 5u8;
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: {
let req_len = size_of::<ProductionAuthDebugUnlockReq>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ),
&request.as_bytes()[4..],
);
let request = ProductionAuthDebugUnlockReq {
hdr: MailboxReqHeader { chksum: checksum },
..request
};
let resp = model
.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ.into(),
request.as_bytes(),
)
.unwrap()
.unwrap();
let challenge = ProductionAuthDebugUnlockChallenge::read_from_bytes(resp.as_slice()).unwrap();
let reserved = [0u8; 3];
let mut sha384 = sha2::Sha384::new();
sha384.update(challenge.unique_device_identifier);
sha384.update([unlock_level]);
sha384.update(reserved);
sha384.update(challenge.challenge);
let sha384_digest = sha384.finalize();
let (ecc_signature, _id) = signing_ecc_key
.sign_prehash_recoverable(sha384_digest.as_slice())
.unwrap();
let ecc_signature = ecc_signature.to_bytes();
let ecc_signature = ecc_signature.as_slice();
// Convert to hardware format i.e. big endian for ECC.
let ecc_signature = u8_to_u32_be(ecc_signature);
let mut sha512 = sha2::Sha512::new();
sha512.update(challenge.unique_device_identifier);
sha512.update([unlock_level]);
sha512.update(reserved);
sha512.update(challenge.challenge);
let sha512_digest = sha512.finalize();
let mldsa_signature = signing_mldsa_key
.try_sign_with_seed(&[0; 32], &sha512_digest, &[])
.unwrap();
// Convert to hardware format i.e. little endian for MLDSA
let mldsa_signature = {
let mut sig = [0; 4628];
sig[..4627].copy_from_slice(&mldsa_signature);
u8_to_u32_le(&sig)
};
let token = ProductionAuthDebugUnlockToken {
length: {
let req_len =
size_of::<ProductionAuthDebugUnlockToken>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unique_device_identifier: challenge.unique_device_identifier,
unlock_level,
challenge: challenge.challenge,
ecc_public_key: ecc_pub_key.try_into().unwrap(),
mldsa_public_key: mldsa_pub_key.try_into().unwrap(),
ecc_signature: ecc_signature.try_into().unwrap(),
mldsa_signature: mldsa_signature.try_into().unwrap(),
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN),
&token.as_bytes()[4..],
);
let token = ProductionAuthDebugUnlockToken {
hdr: MailboxReqHeader { chksum: checksum },
..token
};
let _resp = model
.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN.into(),
token.as_bytes(),
)
.unwrap();
model.step_until(|m| {
let resp = m.soc_ifc().ss_dbg_service_reg_rsp().read();
!resp.prod_dbg_unlock_in_progress()
});
assert!(model
.soc_ifc()
.ss_dbg_service_reg_rsp()
.read()
.prod_dbg_unlock_success());
let mut value = model
.soc_ifc()
.ss_soc_dbg_unlock_level()
.get(0)
.unwrap()
.read();
let mut soc_debug_level = 0;
while value > 1 {
value >>= 1;
soc_debug_level += 1;
}
soc_debug_level += 1;
assert!(soc_debug_level == unlock_level);
}
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_dbg_unlock_prod_invalid_length() {
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, _) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let unlock_level = 2u8;
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: 123u32, // Set an incorrect length
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ),
&request.as_bytes()[4..],
);
let request = ProductionAuthDebugUnlockReq {
hdr: MailboxReqHeader { chksum: checksum },
..request
};
assert_eq!(
model.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ.into(),
request.as_bytes(),
),
Err(ModelError::MailboxCmdFailed(
CaliptraError::SS_DBG_UNLOCK_PROD_INVALID_REQ.into()
))
);
}
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_dbg_unlock_prod_invalid_token_challenge() {
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, _) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let unlock_level = 5u8;
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: {
let req_len = size_of::<ProductionAuthDebugUnlockReq>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ),
&request.as_bytes()[4..],
);
let request = ProductionAuthDebugUnlockReq {
hdr: MailboxReqHeader { chksum: checksum },
..request
};
let resp = model
.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ.into(),
request.as_bytes(),
)
.unwrap()
.unwrap();
let challenge = ProductionAuthDebugUnlockChallenge::read_from_bytes(resp.as_slice()).unwrap();
let invalid_challenge = [0u8; 48];
let token = ProductionAuthDebugUnlockToken {
length: {
let req_len =
size_of::<ProductionAuthDebugUnlockToken>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unique_device_identifier: challenge.unique_device_identifier,
unlock_level,
challenge: invalid_challenge,
ecc_public_key: ecc_pub_key.try_into().unwrap(),
mldsa_public_key: mldsa_pub_key.try_into().unwrap(),
ecc_signature: [0u32; 24], // Invalid signature
mldsa_signature: [0u32; 1157], // Invalid signature
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN),
&token.as_bytes()[4..],
);
let token = ProductionAuthDebugUnlockToken {
hdr: MailboxReqHeader { chksum: checksum },
..token
};
let _ = model.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN.into(),
token.as_bytes(),
);
model.step_until(|m| {
let resp = m.soc_ifc().ss_dbg_service_reg_rsp().read();
!resp.prod_dbg_unlock_in_progress()
});
assert!(model
.soc_ifc()
.ss_dbg_service_reg_rsp()
.read()
.prod_dbg_unlock_fail());
}
#[test]
fn test_dbg_unlock_prod_wrong_public_keys() {
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, _) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
// Generate a different set of keys that aren't registered with the hardware
let different_signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let different_verifying_ecc_key = VerifyingKey::from(&different_signing_ecc_key);
let different_ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = different_verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
let different_ecc_pub_key = u8_to_u32_be(&different_ecc_pub_key_bytes);
let (different_verifying_mldsa_key, _) = fips204::ml_dsa_87::try_keygen().unwrap();
let different_mldsa_pub_key_bytes = different_verifying_mldsa_key.into_bytes();
let different_mldsa_pub_key = u8_to_u32_be(&different_mldsa_pub_key_bytes);
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let unlock_level = 5u8;
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: {
let req_len = size_of::<ProductionAuthDebugUnlockReq>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ),
&request.as_bytes()[4..],
);
let request = ProductionAuthDebugUnlockReq {
hdr: MailboxReqHeader { chksum: checksum },
..request
};
let resp = model
.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ.into(),
request.as_bytes(),
)
.unwrap()
.unwrap();
let challenge = ProductionAuthDebugUnlockChallenge::read_from_bytes(resp.as_slice()).unwrap();
let token = ProductionAuthDebugUnlockToken {
length: {
let req_len =
size_of::<ProductionAuthDebugUnlockToken>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unique_device_identifier: challenge.unique_device_identifier,
unlock_level,
challenge: challenge.challenge,
// Use the different public keys that weren't registered with the hardware
ecc_public_key: different_ecc_pub_key.try_into().unwrap(),
mldsa_public_key: different_mldsa_pub_key.try_into().unwrap(),
ecc_signature: [0u32; 24], // Signature doesn't matter since keys will fail first
mldsa_signature: [0u32; 1157], // Signature doesn't matter since keys will fail first
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN),
&token.as_bytes()[4..],
);
let token = ProductionAuthDebugUnlockToken {
hdr: MailboxReqHeader { chksum: checksum },
..token
};
let _ = model.mailbox_execute(
CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN.into(),
token.as_bytes(),
);
model.step_until(|m| {
let resp = m.soc_ifc().ss_dbg_service_reg_rsp().read();
!resp.prod_dbg_unlock_in_progress()
});
assert!(model
.soc_ifc()
.ss_dbg_service_reg_rsp()
.read()
.prod_dbg_unlock_fail());
}
#[test]
fn test_dbg_unlock_prod_wrong_cmd() {
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, _) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let unlock_level = 5u8;
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: true,
..Default::default()
},
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: {
let req_len = size_of::<ProductionAuthDebugUnlockReq>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
u32::from(CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ),
&request.as_bytes()[4..],
);
let request = ProductionAuthDebugUnlockReq {
hdr: MailboxReqHeader { chksum: checksum },
..request
};
assert_eq!(
model.mailbox_execute(0, request.as_bytes()),
Err(ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_INVALID_CHECKSUM.into()
))
);
}
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_dbg_unlock_prod_unlock_levels_success() {
for unlock_level in 1..=8 {
println!("unlock_level: {}", unlock_level);
let signing_ecc_key = p384::ecdsa::SigningKey::random(&mut StdRng::from_entropy());
let verifying_ecc_key = VerifyingKey::from(&signing_ecc_key);
let ecc_pub_key_bytes = {
let mut pk = [0; 96];
let ecc_key = verifying_ecc_key.to_encoded_point(false);
pk[..48].copy_from_slice(ecc_key.x().unwrap());
pk[48..].copy_from_slice(ecc_key.y().unwrap());
pk
};
// Convert to hardware format i.e. big endian for ECC.
let ecc_pub_key = u8_to_u32_be(&ecc_pub_key_bytes);
let ecc_pub_key_bytes = ecc_pub_key.as_bytes();
let (verifying_mldsa_key, signing_mldsa_key) = fips204::ml_dsa_87::try_keygen().unwrap();
let mldsa_pub_key_bytes = verifying_mldsa_key.into_bytes();
// Convert to hardware format i.e. little endian for MLDSA.
let mldsa_pub_key = u8_to_u32_le(&mldsa_pub_key_bytes);
let mldsa_pub_key_bytes = mldsa_pub_key.as_bytes();
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let mut prod_dbg_unlock_keypairs: Vec<(&[u8; 96], &[u8; 2592])> =
vec![(&[0; 96], &[0; 2592]); 8];
prod_dbg_unlock_keypairs[(unlock_level - 1) as usize] = (
ecc_pub_key_bytes.try_into().unwrap(),
mldsa_pub_key_bytes.try_into().unwrap(),
);
let init_params = InitParams {
rom: &rom,
security_state,
prod_dbg_unlock_keypairs,
debug_intent: true,
subsystem_mode: true,
stack_info: Some(StackInfo::new(image_info)),
..Default::default()
};
let mcu_fw = vec![1, 2, 3, 4];
const IMAGE_SOURCE_IN_REQUEST: u32 = 1;
let mut flags = ImageMetadataFlags(0);
flags.set_image_source(IMAGE_SOURCE_IN_REQUEST);
let crypto = Crypto::default();
let digest = from_hw_format(&crypto.sha384_digest(&mcu_fw).unwrap());
let metadata = vec![AuthManifestImageMetadata {
fw_id: 2,
flags: flags.0,
digest,
..Default::default()
}];
let soc_manifest = create_auth_manifest_with_metadata(metadata);
let soc_manifest = soc_manifest.as_bytes();
let runtime_args = RuntimeTestArgs {
init_params: Some(init_params),
soc_manifest: Some(soc_manifest),
mcu_fw_image: Some(&mcu_fw),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
// Set the request bit
model
.soc_ifc()
.ss_dbg_service_reg_req()
.write(|w| w.prod_dbg_unlock_req(true));
let request = ProductionAuthDebugUnlockReq {
length: {
let req_len =
size_of::<ProductionAuthDebugUnlockReq>() - size_of::<MailboxReqHeader>();
(req_len / size_of::<u32>()) as u32
},
unlock_level,
..Default::default()
};
let checksum = caliptra_common::checksum::calc_checksum(
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_certs.rs | runtime/tests/runtime_integration_tests/test_certs.rs | // Licensed under the Apache-2.0 license
use crate::common::PQC_KEY_TYPE;
use crate::common::{
execute_dpe_cmd, generate_test_x509_cert, get_ecc_fmc_alias_cert, get_mldsa_fmc_alias_cert,
get_rt_alias_ecc384_cert, get_rt_alias_mldsa87_cert, run_rt_test, run_rt_test_pqc, DpeResult,
RuntimeTestArgs, TEST_LABEL,
};
use caliptra_api::SocManager;
use caliptra_builder::firmware::{APP_WITH_UART, APP_WITH_UART_FPGA, FMC_WITH_UART};
use caliptra_builder::ImageOptions;
use caliptra_common::mailbox_api::{
CommandId, GetIdevCertResp, GetIdevEcc384CertReq, GetIdevEcc384InfoResp, GetIdevMldsa87CertReq,
GetIdevMldsa87InfoResp, GetLdevCertResp, GetRtAliasCertResp, MailboxReq, MailboxReqHeader,
StashMeasurementReq,
};
use caliptra_common::x509::get_tbs;
use caliptra_error::CaliptraError;
use caliptra_hw_model::{BootParams, DefaultHwModel, Fuses, HwModel, InitParams};
use caliptra_image_types::FwVerificationPqcKeyType;
use dpe::{
commands::{CertifyKeyCmd, CertifyKeyFlags, Command, DeriveContextCmd, DeriveContextFlags},
context::ContextHandle,
response::{CertifyKeyResp, Response},
};
use openssl::{
asn1::Asn1Time,
bn::BigNum,
ec::{EcGroup, EcKey},
ecdsa::EcdsaSig,
nid::Nid,
pkey::{PKey, Private, Public},
pkey_ml_dsa::{PKeyMlDsaBuilder, PKeyMlDsaParams, Variant},
stack::Stack,
x509::{
store::X509StoreBuilder, verify::X509VerifyFlags, X509StoreContext, X509VerifyResult, X509,
},
};
use zerocopy::{FromBytes, IntoBytes};
#[test]
// Check if the owner and vendor cert validity dates are present in RT Alias cert
fn test_rt_cert_with_custom_dates() {
const VENDOR_CONFIG: (&str, &str) = ("20250101000000Z", "20260101000000Z");
const OWNER_CONFIG: (&str, &str) = ("20270101000000Z", "20280101000000Z");
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
opts.vendor_config
.not_before
.copy_from_slice(VENDOR_CONFIG.0.as_bytes());
opts.vendor_config
.not_after
.copy_from_slice(VENDOR_CONFIG.1.as_bytes());
let mut own_config = opts.owner_config.unwrap();
own_config
.not_before
.copy_from_slice(OWNER_CONFIG.0.as_bytes());
own_config
.not_after
.copy_from_slice(OWNER_CONFIG.1.as_bytes());
opts.owner_config = Some(own_config);
let args = RuntimeTestArgs {
test_image_options: Some(opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_RT_ALIAS_ECC384_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_RT_ALIAS_ECC384_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetRtAliasCertResp>());
let mut rt_resp = GetRtAliasCertResp::default();
rt_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
let not_before: Asn1Time = Asn1Time::from_str(OWNER_CONFIG.0).unwrap();
let not_after: Asn1Time = Asn1Time::from_str(OWNER_CONFIG.1).unwrap();
assert!(rt_cert.not_before() == not_before);
assert!(rt_cert.not_after() == not_after);
}
}
#[test]
fn test_idev_id_ecc384_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// generate 48 byte ECDSA key pair
let ec_group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let ec_key = PKey::from_ec_key(EcKey::generate(&ec_group).unwrap()).unwrap();
let cert = generate_test_x509_cert(&ec_key);
assert!(cert.verify(&ec_key).unwrap());
// Extract the r and s values of the signature
let sig_bytes = cert.signature().as_slice();
let signature = EcdsaSig::from_der(sig_bytes).unwrap();
let signature_r: [u8; 48] = signature.r().to_vec_padded(48).unwrap().try_into().unwrap();
let signature_s: [u8; 48] = signature.s().to_vec_padded(48).unwrap().try_into().unwrap();
// Extract tbs from cert using the derived TBS size
let tbs = get_tbs(cert.to_der().unwrap());
let tbs_len = tbs.len();
let mut req = GetIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
tbs: [0; GetIdevEcc384CertReq::DATA_MAX_SIZE],
signature_r,
signature_s,
tbs_size: tbs_len as u32,
};
req.tbs[..tbs_len].copy_from_slice(&tbs);
let mut cmd = MailboxReq::GetIdevEcc384Cert(req);
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_ECC384_CERT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We expected a response");
assert!(resp.len() <= std::mem::size_of::<GetIdevCertResp>());
let mut cert = GetIdevCertResp::default();
cert.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
assert!(caliptra_common::checksum::verify_checksum(
cert.hdr.chksum,
0x0,
&resp[core::mem::size_of_val(&cert.hdr.chksum)..],
));
assert!(tbs_len < cert.data_size as usize);
let idev_cert = X509::from_der(&cert.data[..cert.data_size as usize]).unwrap();
assert!(idev_cert.verify(&ec_key).unwrap());
}
#[test]
fn test_idev_id_mldsa87_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Generate MLDSA key pair
let seed = [0x42u8; 32]; // Use a deterministic seed for testing
let builder = PKeyMlDsaBuilder::<Private>::from_seed(Variant::MlDsa87, &seed).unwrap();
let private_key = builder.build().unwrap();
// Extract public key for verification
let public_params = PKeyMlDsaParams::<Public>::from_pkey(&private_key).unwrap();
let public_key = PKeyMlDsaBuilder::<Public>::new(
Variant::MlDsa87,
public_params.public_key().unwrap(),
None,
)
.unwrap()
.build()
.unwrap();
let cert = generate_test_x509_cert(&private_key);
assert!(cert.verify(&public_key).unwrap());
// Extract signature from cert
let sig_bytes = cert.signature().as_slice();
let mut signature = [0u8; 4628];
signature[..sig_bytes.len()].copy_from_slice(sig_bytes);
// Extract tbs from cert using the derived TBS size
let cert_der_vec = cert.to_der().unwrap();
let tbs_data = get_tbs(cert_der_vec);
let actual_tbs_size = std::cmp::min(tbs_data.len(), GetIdevMldsa87CertReq::DATA_MAX_SIZE);
let mut req = GetIdevMldsa87CertReq {
hdr: MailboxReqHeader { chksum: 0 },
tbs: [0u8; GetIdevMldsa87CertReq::DATA_MAX_SIZE],
signature,
tbs_size: actual_tbs_size as u32,
};
req.tbs[..actual_tbs_size].copy_from_slice(&tbs_data[..actual_tbs_size]);
let mut cmd = MailboxReq::GetIdevMldsa87Cert(req);
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_MLDSA87_CERT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We expected a response");
assert!(resp.len() <= std::mem::size_of::<GetIdevCertResp>());
let mut cert = GetIdevCertResp::default();
cert.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
assert!(caliptra_common::checksum::verify_checksum(
cert.hdr.chksum,
0x0,
&resp[core::mem::size_of_val(&cert.hdr.chksum)..],
));
assert!(actual_tbs_size < cert.data_size as usize);
let idev_cert = X509::from_der(&cert.data[..cert.data_size as usize]).unwrap();
assert!(idev_cert.verify(&public_key).unwrap());
}
#[test]
fn test_idev_id_cert_size_too_big() {
// Test with tbs_size too big.
let mut cmd = MailboxReq::GetIdevEcc384Cert(GetIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
tbs: [0u8; GetIdevEcc384CertReq::DATA_MAX_SIZE],
signature_r: [0u8; 48],
signature_s: [0u8; 48],
tbs_size: GetIdevEcc384CertReq::DATA_MAX_SIZE as u32 + 1,
});
assert_eq!(
cmd.populate_chksum(),
Err(CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE)
);
}
fn get_ldev_ecc_cert(model: &mut DefaultHwModel) -> GetLdevCertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_LDEV_ECC384_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_LDEV_ECC384_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetLdevCertResp>());
let mut ldev_resp = GetLdevCertResp::default();
ldev_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
ldev_resp
}
fn get_ldev_mldsa_cert(model: &mut DefaultHwModel) -> GetLdevCertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_LDEV_MLDSA87_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_LDEV_MLDSA87_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetLdevCertResp>());
let mut ldev_resp = GetLdevCertResp::default();
ldev_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
ldev_resp
}
#[test]
fn test_ldev_ecc384_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_ecc_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
// Get IDev public key
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_ECC384_INFO),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_ECC384_INFO),
payload.as_bytes(),
)
.unwrap()
.unwrap();
let idev_resp = GetIdevEcc384InfoResp::read_from_bytes(resp.as_slice()).unwrap();
// Check the LDevID is signed by IDevID
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let idev_x = &BigNum::from_slice(&idev_resp.idev_pub_x).unwrap();
let idev_y = &BigNum::from_slice(&idev_resp.idev_pub_y).unwrap();
let idev_ec_key = EcKey::from_public_key_affine_coordinates(&group, idev_x, idev_y).unwrap();
assert!(ldev_cert
.verify(&PKey::from_ec_key(idev_ec_key).unwrap())
.unwrap());
}
#[test]
fn test_get_ldev_mldsa_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_mldsa_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
// Get IDev MLDSA public key
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_MLDSA87_INFO),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_MLDSA87_INFO),
payload.as_bytes(),
)
.unwrap()
.unwrap();
let idev_resp = GetIdevMldsa87InfoResp::read_from_bytes(resp.as_slice()).unwrap();
// Check the LDevID is signed by IDevID
let idev_public_key =
PKeyMlDsaBuilder::<Public>::new(Variant::MlDsa87, &idev_resp.idev_pub_key, None)
.unwrap()
.build()
.unwrap();
assert!(ldev_cert.verify(&idev_public_key).unwrap());
}
#[test]
fn test_fmc_alias_ecc384_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_ecc_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
let fmc_resp = get_ecc_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
// Check the FMC is signed by LDevID and that subject/issuer names match
assert!(fmc_cert.verify(&ldev_cert.public_key().unwrap()).unwrap());
assert_eq!(
fmc_cert
.issuer_name()
.try_cmp(ldev_cert.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
}
#[test]
fn test_fmc_alias_mldsa87_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_mldsa_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
let fmc_resp = get_mldsa_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
// Check the FMC is signed by LDevID and that subject/issuer names match
assert!(fmc_cert.verify(&ldev_cert.public_key().unwrap()).unwrap());
assert_eq!(
fmc_cert
.issuer_name()
.try_cmp(ldev_cert.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
}
#[test]
fn test_rt_alias_ecc384_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let fmc_resp = get_ecc_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let rt_resp = get_rt_alias_ecc384_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
// Check that RT Alias is signed by FMC and that subject/issuer names match
assert!(rt_cert.verify(&fmc_cert.public_key().unwrap()).unwrap());
assert_eq!(
rt_cert
.issuer_name()
.try_cmp(fmc_cert.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
}
#[test]
fn test_rt_alias_mldsa87_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let fmc_resp = get_mldsa_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let rt_resp = get_rt_alias_mldsa87_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
// Check that RT Alias is signed by FMC and that subject/issuer names match
assert!(rt_cert.verify(&fmc_cert.public_key().unwrap()).unwrap());
assert_eq!(
rt_cert
.issuer_name()
.try_cmp(fmc_cert.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
}
#[test]
fn test_dpe_leaf_cert() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let rt_resp = get_rt_alias_ecc384_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
let dpe_leaf_cert: X509 =
X509::from_der(&certify_key_resp.cert[..certify_key_resp.cert_size as usize]).unwrap();
// Check that DPE Leaf Cert is signed by RT alias pub key and that subject/issuer names match
assert!(dpe_leaf_cert
.verify(&rt_cert.public_key().unwrap())
.unwrap());
assert_eq!(
dpe_leaf_cert
.issuer_name()
.try_cmp(rt_cert.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
}
#[test]
fn test_full_cert_chain_ecc384() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_ecc_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
let fmc_resp = get_ecc_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let rt_resp = get_rt_alias_ecc384_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
// Verify full cert chain
let mut roots_bldr = X509StoreBuilder::new().unwrap();
roots_bldr.add_cert(ldev_cert).unwrap();
roots_bldr
.set_flags(X509VerifyFlags::X509_STRICT | X509VerifyFlags::PARTIAL_CHAIN)
.unwrap();
let roots = roots_bldr.build();
let mut cert_store = X509StoreContext::new().unwrap();
let mut chain = Stack::new().unwrap();
chain.push(fmc_cert).unwrap();
cert_store
.init(&roots, &rt_cert, &chain, |c| {
let success = c.verify_cert().unwrap();
assert_eq!(c.error(), X509VerifyResult::OK);
assert!(success);
Ok(())
})
.unwrap();
}
#[test]
fn test_full_cert_chain_mldsa87() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let ldev_resp = get_ldev_mldsa_cert(&mut model);
let ldev_cert: X509 = X509::from_der(&ldev_resp.data[..ldev_resp.data_size as usize]).unwrap();
let fmc_resp = get_mldsa_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let rt_resp = get_rt_alias_mldsa87_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
// Verify full cert chain
let mut roots_bldr = X509StoreBuilder::new().unwrap();
roots_bldr.add_cert(ldev_cert).unwrap();
roots_bldr
.set_flags(X509VerifyFlags::X509_STRICT | X509VerifyFlags::PARTIAL_CHAIN)
.unwrap();
let roots = roots_bldr.build();
let mut cert_store = X509StoreContext::new().unwrap();
let mut chain = Stack::new().unwrap();
chain.push(fmc_cert).unwrap();
cert_store
.init(&roots, &rt_cert, &chain, |c| {
let success = c.verify_cert().unwrap();
assert_eq!(c.error(), X509VerifyResult::OK);
assert!(success);
Ok(())
})
.unwrap();
}
fn get_dpe_leaf_cert(model: &mut DefaultHwModel) -> CertifyKeyResp {
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
certify_key_resp
}
// Helper for cold reset compatible with SW emulator
// NOTE: Assumes all other boot and init params are default except for ROM and FW image
fn cold_reset(
mut hw: DefaultHwModel,
rom: &[u8],
fw_image: &[u8],
pqc_key_type: FwVerificationPqcKeyType,
) -> DefaultHwModel {
if cfg!(any(
feature = "fpga_realtime",
feature = "verilator",
feature = "fpga_subsystem"
)) {
// Re-creating the model does not seem to work for FPGA (and SW emulator cannot cold reset)
hw.cold_reset();
} else {
let fuses = Fuses {
fuse_pqc_key_type: pqc_key_type as u32,
..Default::default()
};
hw = caliptra_hw_model::new_unbooted(InitParams {
fuses,
rom,
..Default::default()
})
.unwrap();
}
hw.boot(BootParams {
fw_image: Some(fw_image),
..Default::default()
})
.unwrap();
hw
}
// Provide a measurement to Caliptra using each of the 3 methods
// 1. Stash measurement at ROM
// 2. Stash measurement at runtime
// 3. DPE derive context (at runtime)
// Confirm the resulting DPE leaf cert is identical in all three cases
#[test]
#[allow(dead_code)]
pub fn test_all_measurement_apis() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let image_options = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
// Shared inputs for all 3 methods
let measurement: [u8; 48] = core::array::from_fn(|i| (i + 1) as u8);
let tci_type: [u8; 4] = [101, 102, 103, 104];
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
&if cfg!(feature = "fpga_subsystem") {
APP_WITH_UART_FPGA
} else {
APP_WITH_UART
},
image_options,
)
.unwrap()
.to_bytes()
.unwrap();
//
// 1. ROM STASH MEASUREMENT
// Stash a measurement, boot to runtime, then get the DPE cert
// Start with a fresh cold boot for each method
//
let fuses = Fuses {
fuse_pqc_key_type: *pqc_key_type as u32,
..Default::default()
};
let mut hw = caliptra_hw_model::new(
InitParams {
fuses,
rom: &rom,
..Default::default()
},
BootParams {
..Default::default()
},
)
.unwrap();
// Send the stash measurement command
let mut stash_measurement_payload = MailboxReq::StashMeasurement(StashMeasurementReq {
hdr: MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::STASH_MEASUREMENT),
&[],
),
},
metadata: tci_type.as_bytes().try_into().unwrap(),
measurement,
..Default::default()
});
stash_measurement_payload.populate_chksum().unwrap();
let _resp = hw
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
stash_measurement_payload.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
// Get to runtime
crate::common::test_upload_firmware(&mut hw, &fw_image, *pqc_key_type);
hw.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
// Get DPE cert
let dpe_cert_resp = get_dpe_leaf_cert(&mut hw);
let rom_stash_dpe_cert = &dpe_cert_resp.cert[..dpe_cert_resp.cert_size as usize];
//
// 2. RUNTIME STASH MEASUREMENT
// Boot to runtime, stash a measurement, then get the DPE cert
// Start with a fresh cold boot for each method
//
hw = cold_reset(hw, &rom, &fw_image, *pqc_key_type);
hw.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
// Send the stash measurement command
let _resp = hw
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
stash_measurement_payload.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
// Get DPE cert
let dpe_cert_resp = get_dpe_leaf_cert(&mut hw);
let rt_stash_dpe_cert = &dpe_cert_resp.cert[..dpe_cert_resp.cert_size as usize];
//
// 3. DPE DERIVE CONTEXT
// Boot to runtime, perform DPE derive context, then get the DPE cert
// Start with a fresh cold boot for each method
//
hw = cold_reset(hw, &rom, &fw_image, *pqc_key_type);
hw.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
// Send derive context call
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: measurement,
flags: DeriveContextFlags::MAKE_DEFAULT
| DeriveContextFlags::ALLOW_NEW_CONTEXT_TO_EXPORT
| DeriveContextFlags::INPUT_ALLOW_X509,
tci_type: u32::read_from_bytes(&tci_type[..]).unwrap(),
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut hw,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(_derive_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
// Get DPE cert
let dpe_cert_resp = get_dpe_leaf_cert(&mut hw);
let derive_context_dpe_cert = &dpe_cert_resp.cert[..dpe_cert_resp.cert_size as usize];
//
// COMPARE CERTS
// Certs should be exactly the same regardless of method
//
assert_eq!(rom_stash_dpe_cert, rt_stash_dpe_cert);
assert_eq!(rom_stash_dpe_cert, derive_context_dpe_cert);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_sign_with_export_ecdsa.rs | runtime/tests/runtime_integration_tests/test_sign_with_export_ecdsa.rs | // Licensed under the Apache-2.0 license
use caliptra_api::{
mailbox::{MailboxRespHeader, RevokeExportedCdiHandleReq},
SocManager,
};
use caliptra_common::mailbox_api::{
CommandId, MailboxReq, MailboxReqHeader, SignWithExportedEcdsaReq, SignWithExportedEcdsaResp,
};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{HwModel, ModelError, SecurityState};
use caliptra_runtime::RtBootStatus;
use crypto::{CryptoError, MAX_EXPORTED_CDI_SIZE};
use dpe::{
commands::{Command, DeriveContextCmd, DeriveContextFlags, RotateCtxCmd, RotateCtxFlags},
context::ContextHandle,
response::{
DeriveContextExportedCdiResp, DeriveContextResp, DpeErrorCode, NewHandleResp, Response,
},
DPE_PROFILE,
};
use openssl::{
bn::BigNum,
ec::{EcGroup, EcKey},
ecdsa::EcdsaSig,
nid::Nid,
x509::X509,
};
use zerocopy::{FromBytes, IntoBytes};
use crate::common::{
assert_error, execute_dpe_cmd, run_rt_test, DpeResult, RuntimeTestArgs, TEST_DIGEST,
};
fn check_certificate_signature(
sign_resp: &SignWithExportedEcdsaResp,
exported_cdi_resp: &DeriveContextExportedCdiResp,
) -> bool {
let sig = EcdsaSig::from_private_components(
BigNum::from_slice(&sign_resp.signature_r).unwrap(),
BigNum::from_slice(&sign_resp.signature_s).unwrap(),
)
.unwrap();
// Verify that the certificate from DeriveContext can verify the signature.
let x509 = X509::from_der(
&exported_cdi_resp.new_certificate
[..exported_cdi_resp.certificate_size.try_into().unwrap()],
)
.unwrap();
let ec_pub_key = x509.public_key().unwrap().ec_key().unwrap();
if !sig.verify(&TEST_DIGEST, &ec_pub_key).unwrap() {
return false;
}
// Let's also check that the returned public key can verify the signature.
let x = BigNum::from_slice(&sign_resp.derived_pubkey_x).unwrap();
let y = BigNum::from_slice(&sign_resp.derived_pubkey_y).unwrap();
let ec_pub_key = EcKey::from_public_key_affine_coordinates(
&EcGroup::from_curve_name(Nid::SECP384R1).unwrap(),
&x,
&y,
)
.unwrap();
sig.verify(&TEST_DIGEST, &ec_pub_key).unwrap()
}
#[test]
fn test_sign_with_exported_cdi() {
// Exports a CDI and then signs a well known hash.
// Verifies the signature using the CA certificate paired with the export-cdi, as well as the
// public key returned by SIGN_WITH_EXPORTED_ECDSA.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let derive_ctx_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
let derive_resp = match resp {
Some(Response::DeriveContextExportedCdi(resp)) => resp,
_ => panic!("expected derive context resp!"),
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: derive_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &derive_resp));
}
#[test]
fn test_sign_with_exported_incorrect_cdi_handle() {
// Verifies that an invalid CDI handle cannot derive an exported ECDSA key.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let get_cert_chain_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&get_cert_chain_cmd),
DpeResult::Success,
);
match resp {
Some(Response::DeriveContextExportedCdi(resp)) => resp,
_ => panic!("expected derive context resp!"),
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: [0xFF; MAX_EXPORTED_CDI_SIZE],
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
assert_eq!(
result.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_SIGN_WITH_EXPORTED_ECDSA_KEY_DERIVIATION_FAILED.into(),
)
);
}
#[test]
fn test_sign_with_exported_never_derived() {
// Verifies that an exported ECDSA key cannot be derived without first exporting a CDI.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: [0xFF; MAX_EXPORTED_CDI_SIZE],
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
assert_eq!(
result.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_SIGN_WITH_EXPORTED_ECDSA_KEY_DERIVIATION_FAILED.into(),
)
);
}
#[test]
fn test_sign_with_exported_cdi_measurement_update_duplicate_cdi() {
// Tests the following sequence:
// 1. Export a CDI.
// - This CDI is know as the "original_cdi".
// 2. Verify signing of `SIGN_WITH_EXPORTED_ECDSA` with the CA signed by the "original_cdi".
// 3. Add a new measurement using the `DeriveContextFlags::RECURSIVE` flag.
// 4. Try to export a new CDI, verify that it failes with
// `DpeErrorCode::Crypto(CryptoError::ExportedCdiHandleDuplicateCdi))`.
// 5. Verify signing of `SIGN_WITH_EXPORTED_ECDSA` with the CA signed by the "original_cdi".
// This ensures that the failure in step 4 did not overwrite the "original_cdi".
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(original_cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: original_cdi_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &original_cdi_resp));
let measurement_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0xa; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::RECURSIVE,
tci_type: u32::from_be_bytes(*b"MBVP"),
target_locality: 0,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&measurement_cmd),
DpeResult::Success,
);
let Some(Response::Error(e)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::DpeCmdFailure,
) else {
panic!("Expected the second export cdi command to fail.")
};
assert_eq!(
e.status,
DpeErrorCode::Crypto(CryptoError::ExportedCdiHandleDuplicateCdi).get_error_code()
);
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: original_cdi_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &original_cdi_resp));
}
#[test]
fn test_sign_with_exported_cdi_measurement_update() {
// Tests the following sequence:
// 1. Export a CDI.
// - This CDI is know as the "original_cdi".
// 2. Add a new measurement using the `DeriveContextFlags::RECURSIVE` flag.
// 3. Revoke the "original_cdi".
// 3. Export a new CDI known as the "updated_cdi".
// 4. Verify that the signature from `SIGN_WITH_EXPORTED_ECDSA` cannot be verified by the CA
// cert paired with the "original_cdi".
// 5. Verify signing of `SIGN_WITH_EXPORTED_ECDSA` with the CA cert signed by the "updated_cdi"
// to make sure that we can create valid signatures that map with the "update_cdi" CA cert.
// 6. Double check that the certificate and export_cdi have changed between "original_cdi" and
// "update_cdi".
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(original_cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let measurement_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0xa; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::RECURSIVE,
tci_type: u32::from_be_bytes(*b"MBVP"),
target_locality: 0,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&measurement_cmd),
DpeResult::Success,
);
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: original_cdi_resp.exported_cdi,
});
cmd.populate_chksum().unwrap();
match model.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
) {
Ok(_) => (),
Err(e) => panic!("REVOKE_EXPORTED_CDI_HANDLE failed with {:?}", e),
}
let Some(Response::DeriveContextExportedCdi(updated_cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: updated_cdi_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
// The original CDI was revoked.
assert!(!check_certificate_signature(sign_resp, &original_cdi_resp));
assert!(check_certificate_signature(sign_resp, &updated_cdi_resp));
assert_ne!(original_cdi_resp, updated_cdi_resp);
assert_ne!(
original_cdi_resp.exported_cdi,
updated_cdi_resp.exported_cdi
);
assert_ne!(
original_cdi_resp.new_certificate,
updated_cdi_resp.new_certificate
);
}
#[test]
fn test_sign_with_revoked_exported_cdi() {
// This tests the following sequence:
// 1. Create an exported-cdi
// 2. Check that we can create a valid signature with it.
// 3. Revoke the exported-cdi.
// 4. Verify that we can no longer sign with the exported-cdi and that `SIGN_WITH_EXPORTED_ECDSA`
// returns `CaliptraError::RUNTIME_SIGN_WITH_EXPORTED_ECDSA_KEY_DERIVIATION_FAILED`.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut sign_cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: cdi_resp.exported_cdi,
tbs: TEST_DIGEST,
});
sign_cmd.populate_chksum().unwrap();
let result = model
.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
sign_cmd.as_bytes().unwrap(),
)
.expect("SIGN_WITH_EXPORTED_ECDSA should not fail until the handle is revoked")
.unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(result.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &cdi_resp));
let mut revoke_cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: cdi_resp.exported_cdi,
});
revoke_cmd.populate_chksum().unwrap();
match model.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
revoke_cmd.as_bytes().unwrap(),
) {
Ok(_) => (),
Err(e) => panic!("REVOKE_EXPORTED_CDI_HANDLE failed with {:?}", e),
}
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
sign_cmd.as_bytes().unwrap(),
);
assert_error(
&mut model,
CaliptraError::RUNTIME_SIGN_WITH_EXPORTED_ECDSA_KEY_DERIVIATION_FAILED,
result.err().unwrap(),
);
}
#[test]
fn test_sign_with_disabled_attestation() {
// This tests the following sequence:
// 1. Create an exported-cdi
// 2. Check that we can create a valid signature with it.
// 3. Disable attestation
// 4. Verify that the signature is no longer valid.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut sign_cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: cdi_resp.exported_cdi,
tbs: TEST_DIGEST,
});
sign_cmd.populate_chksum().unwrap();
let result = model
.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
sign_cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(result.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &cdi_resp));
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::DISABLE_ATTESTATION),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::DISABLE_ATTESTATION),
payload.as_bytes(),
)
.unwrap()
.unwrap();
let resp_hdr = MailboxRespHeader::read_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let result = model
.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
sign_cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(result.as_bytes()).unwrap();
assert!(!check_certificate_signature(sign_resp, &cdi_resp));
}
#[test]
fn test_sign_with_exported_cdi_warm_reset() {
// 1. Exports a CDI and then signs a well known hash.
// 2. Verifies the signature using the CA certificate paired with the export-cdi, as well as the
// public key returned by SIGN_WITH_EXPORTED_ECDSA.
// 3. Performs a warm reset
// 4. Checks that we can still create a valid signature.
let mut model = run_rt_test(RuntimeTestArgs {
security_state: Some(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Production)
.set_debug_locked(true),
),
..Default::default()
});
let derive_ctx_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
let derive_resp = match resp {
Some(Response::DeriveContextExportedCdi(resp)) => resp,
_ => panic!("expected derive context resp!"),
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: derive_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &derive_resp));
// Wait for command to finish
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().mailbox_flow_done());
// Triggering a warm reset while a command is being processed will disable attestation.
for _ in 0..1000 {
model.step();
}
model.warm_reset_flow().unwrap();
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: derive_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &derive_resp));
}
#[test]
fn test_sign_with_exported_cdi_warm_reset_parent() {
// 1. Exports a CDI that has children and then signs a well known hash.
// 2. Verifies the signature using the CA certificate paired with the export-cdi, as well as the
// public key returned by SIGN_WITH_EXPORTED_ECDSA.
// 3. Performs a warm reset
// 4. Checks that we can still create a valid signature. This implicitly checks that the root
// context was not destroyed, since we can still find it in the runtime.
let mut model = run_rt_test(RuntimeTestArgs {
security_state: Some(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Production)
.set_debug_locked(true),
),
..Default::default()
});
// Rotate out the default handle so we can make multiple descendants.
let rotate_ctx_cmd = RotateCtxCmd {
handle: ContextHandle::default(),
flags: RotateCtxFlags::empty(),
};
let Some(Response::RotateCtx(NewHandleResp { handle, .. })) = execute_dpe_cmd(
&mut model,
&mut Command::RotateCtx(&rotate_ctx_cmd),
DpeResult::Success,
) else {
panic!("Failed to rotate context!");
};
// Derive a new context and retain the parent.
// We will export the parent. We expect that the child prevents the dpe context chain from being destroyed.
let derive_ctx_cmd = DeriveContextCmd {
handle,
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(DeriveContextResp { parent_handle, .. })) = resp else {
panic!("expected derive context resp!");
};
// Export the parent context from the last derive command.
let derive_ctx_cmd = DeriveContextCmd {
handle: parent_handle,
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
let derive_resp = match resp {
Some(Response::DeriveContextExportedCdi(resp)) => resp,
_ => panic!("expected derive context resp!"),
};
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: derive_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &derive_resp));
// Wait for command to finish
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().mailbox_flow_done());
// Triggering a warm reset while a command is being processed will disable attestation.
for _ in 0..1000 {
model.step();
}
model.warm_reset_flow().unwrap();
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: derive_resp.exported_cdi,
tbs: TEST_DIGEST,
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::SIGN_WITH_EXPORTED_ECDSA.into(),
cmd.as_bytes().unwrap(),
);
let response = result.unwrap().unwrap();
let sign_resp = SignWithExportedEcdsaResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(check_certificate_signature(sign_resp, &derive_resp));
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_disable.rs | runtime/tests/runtime_integration_tests/test_disable.rs | // Licensed under the Apache-2.0 license
use caliptra_builder::{
firmware::{APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::mailbox_api::{CommandId, FwInfoResp, MailboxReqHeader, MailboxRespHeader};
use caliptra_hw_model::HwModel;
use caliptra_image_types::FwVerificationPqcKeyType;
use dpe::{
commands::{CertifyKeyCmd, CertifyKeyFlags, Command, SignCmd, SignFlags},
context::ContextHandle,
response::Response,
};
use openssl::{
bn::BigNum,
ec::{EcGroup, EcKey},
ecdsa::EcdsaSig,
nid::Nid,
x509::X509,
};
use zerocopy::{FromBytes, IntoBytes};
use crate::common::{
execute_dpe_cmd, get_rt_alias_ecc384_cert, run_rt_test, DpeResult, RuntimeTestArgs,
TEST_DIGEST, TEST_LABEL,
};
#[test]
fn test_disable_attestation_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// sign the digest
let sign_cmd = SignCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: SignFlags::empty(),
digest: TEST_DIGEST,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::Sign(&sign_cmd),
DpeResult::Success,
);
let Some(Response::Sign(sign_resp)) = resp else {
panic!("Wrong response type!");
};
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::DISABLE_ATTESTATION),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::DISABLE_ATTESTATION),
payload.as_bytes(),
)
.unwrap()
.unwrap();
let resp_hdr = MailboxRespHeader::read_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// get pub key
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
let sig = EcdsaSig::from_private_components(
BigNum::from_slice(&sign_resp.sig_r).unwrap(),
BigNum::from_slice(&sign_resp.sig_s).unwrap(),
)
.unwrap();
let ecc_pub_key = EcKey::from_public_key_affine_coordinates(
&EcGroup::from_curve_name(Nid::SECP384R1).unwrap(),
&BigNum::from_slice(&certify_key_resp.derived_pubkey_x).unwrap(),
&BigNum::from_slice(&certify_key_resp.derived_pubkey_y).unwrap(),
)
.unwrap();
// check that signature is unable to be verified by the pub key
assert!(!sig.verify(&TEST_DIGEST, &ecc_pub_key).unwrap());
}
#[test]
fn test_attestation_disabled_flag_after_update_reset() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// disable attestation
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::DISABLE_ATTESTATION),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::DISABLE_ATTESTATION),
payload.as_bytes(),
)
.unwrap()
.unwrap();
let resp_hdr = MailboxRespHeader::read_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// trigger update reset to same firmware
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let updated_fw_image =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
// check attestation disabled via FW_INFO
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(info.attestation_disabled, 1);
// test that attestation is really disabled by checking that
// the dpe leaf cert cannot be verified by rt alias key
let rt_resp = get_rt_alias_ecc384_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
let dpe_leaf_cert: X509 =
X509::from_der(&certify_key_resp.cert[..certify_key_resp.cert_size as usize]).unwrap();
assert!(!dpe_leaf_cert
.verify(&rt_cert.public_key().unwrap())
.unwrap());
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_certs_384_warmreset.rs | runtime/tests/runtime_integration_tests/test_certs_384_warmreset.rs | // Licensed under the Apache-2.0 license
use crate::common::{
assert_x509_semantic_eq, execute_dpe_cmd, generate_test_x509_cert, get_ecc_fmc_alias_cert,
get_rt_alias_ecc384_cert, run_rt_test_pqc, DpeResult, RuntimeTestArgs,
};
use caliptra_common::{
checksum::verify_checksum,
mailbox_api::{
CommandId, GetIdevCertResp, GetIdevEcc384CertReq, GetIdevEcc384InfoResp, GetLdevCertResp,
MailboxReq, MailboxReqHeader, MailboxRespHeader, PopulateIdevEcc384CertReq,
},
x509::get_tbs,
};
use caliptra_hw_model::{DefaultHwModel, HwModel};
use dpe::{
commands::{Command, GetCertificateChainCmd},
response::Response,
};
use openssl::{
bn::{BigNum, BigNumContext},
ec::{EcGroup, EcKey, EcPoint},
ecdsa::EcdsaSig,
nid::Nid,
pkey::{PKey, Private},
x509::X509,
};
use zerocopy::{FromBytes, IntoBytes};
fn get_full_cert_chain(model: &mut DefaultHwModel, out: &mut [u8; 4096]) -> usize {
// first half
let get_cert_chain_cmd = GetCertificateChainCmd {
offset: 0,
size: 2048,
};
let resp = execute_dpe_cmd(
model,
&mut Command::GetCertificateChain(&get_cert_chain_cmd),
DpeResult::Success,
);
let Some(Response::GetCertificateChain(cert_chunk_1)) = resp else {
panic!("Wrong response type!");
};
out[..cert_chunk_1.certificate_size as usize]
.copy_from_slice(&cert_chunk_1.certificate_chain[..cert_chunk_1.certificate_size as usize]);
// second half
let get_cert_chain_cmd = GetCertificateChainCmd {
offset: cert_chunk_1.certificate_size,
size: 2048,
};
let resp = execute_dpe_cmd(
model,
&mut Command::GetCertificateChain(&get_cert_chain_cmd),
DpeResult::Success,
);
let Some(Response::GetCertificateChain(cert_chunk_2)) = resp else {
panic!("Wrong response type!");
};
out[cert_chunk_1.certificate_size as usize
..cert_chunk_1.certificate_size as usize + cert_chunk_2.certificate_size as usize]
.copy_from_slice(&cert_chunk_2.certificate_chain[..cert_chunk_2.certificate_size as usize]);
cert_chunk_1.certificate_size as usize + cert_chunk_2.certificate_size as usize
}
// Will panic if any of the cert chain chunks is not a valid X.509 cert
fn parse_cert_chain(cert_chain: &[u8], cert_chain_size: usize, expected_num_certs: u32) {
let mut i = 0;
let mut cert_count = 0;
while i < cert_chain_size {
let curr_cert = X509::from_der(&cert_chain[i..]).unwrap();
i += curr_cert.to_der().unwrap().len();
cert_count += 1;
}
assert_eq!(expected_num_certs, cert_count);
}
/// Deterministically derive a P-384 EC key from `seed`.
/// Same seed => same key.
pub fn deterministic_p384_key_from_seed() -> PKey<Private> {
// Curve group and order n
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let mut n = BigNum::new().unwrap();
group
.order(&mut n, &mut BigNumContext::new().unwrap())
.unwrap();
let d = BigNum::from_hex_str(
"3A1F4C9B2D7E11A0C4B85566778899AABBCCDDEEFF00112233445566778899AABBCCDDEE",
)
.unwrap();
// Q = d·G
let ctx = BigNumContext::new().unwrap();
let mut q = EcPoint::new(&group).unwrap();
q.mul_generator(&group, &d, &ctx).unwrap();
// EcKey(d, Q) -> PKey
let ec_key = EcKey::from_private_components(&group, &d, &q).unwrap();
PKey::from_ec_key(ec_key).unwrap()
}
/// Issue GET_IDEV_ECC384_CERT once and return the parsed X509.
fn get_idev_384_cert(model: &mut DefaultHwModel) -> (Vec<u8>, X509) {
// Build deterministic ec_Key so pub key will be the same
let ec_key = deterministic_p384_key_from_seed();
let cert = generate_test_x509_cert(&ec_key);
assert!(
cert.verify(&ec_key).unwrap(),
"self-check: test cert must verify"
);
let sig_bytes = cert.signature().as_slice();
let signature = EcdsaSig::from_der(sig_bytes).unwrap();
let signature_r: [u8; 48] = signature.r().to_vec_padded(48).unwrap().try_into().unwrap();
let signature_s: [u8; 48] = signature.s().to_vec_padded(48).unwrap().try_into().unwrap();
let tbs = get_tbs(cert.to_der().unwrap());
let tbs_len = tbs.len();
let mut req = GetIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
tbs: [0; GetIdevEcc384CertReq::DATA_MAX_SIZE],
signature_r,
signature_s,
tbs_size: tbs_len as u32,
};
req.tbs[..tbs_len].copy_from_slice(&tbs);
let mut cmd = MailboxReq::GetIdevEcc384Cert(req);
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_ECC384_CERT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("expected response");
assert!(
resp.len() <= core::mem::size_of::<GetIdevCertResp>(),
"unexpected payload size"
);
let mut cert_resp = GetIdevCertResp::default();
cert_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
// Verify checksum on variable-sized payload (everything after chksum)
assert!(
verify_checksum(
cert_resp.hdr.chksum,
0x0,
&resp[core::mem::size_of_val(&cert_resp.hdr.chksum)..],
),
"response checksum invalid"
);
assert_eq!(
cert_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED,
"CERT FIPS not APPROVED"
);
let size = cert_resp.data_size as usize;
assert!(size <= cert_resp.data.len(), "data_size exceeds buffer");
let der: Vec<u8> = cert_resp.data[..size].to_vec();
let x509 = X509::from_der(&der).unwrap();
(der, x509)
}
#[test]
fn test_get_idev_ecc384_cert_after_warm_reset() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// Before warm reset
let (_raw_before, cert_before) = get_idev_384_cert(&mut model);
// Warm reset
model.warm_reset_flow().unwrap();
// After warm reset
let (_raw_after, cert_after) = get_idev_384_cert(&mut model);
/*assert_eq!(
_raw_before, _raw_after,
"IDev certificate changed across warm reset"
);
assert_eq!(
cert_before, cert_after,
"IDev certificate changed across warm reset"
);*/
// Compare semantically
assert_x509_semantic_eq(&cert_before, &cert_after);
}
/// Issue GET_IDEV_ECC384_INFO once, verify checksum + FIPS Approved,
/// and return (parsed, X, Y, EC public key).
fn get_idev_384_info(
model: &mut DefaultHwModel,
) -> (
GetIdevEcc384InfoResp,
BigNum,
BigNum,
PKey<openssl::pkey::Public>,
) {
// Header-only request with checksum
let hdr = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_ECC384_INFO),
&[],
),
};
let resp_bytes = model
.mailbox_execute(u32::from(CommandId::GET_IDEV_ECC384_INFO), hdr.as_bytes())
.unwrap()
.unwrap();
// Size guard
assert!(
resp_bytes.len() <= core::mem::size_of::<GetIdevEcc384InfoResp>(),
"GetIdevEcc384InfoResp too large: {}",
resp_bytes.len()
);
// Parse into fixed struct buffer
let idev_resp = GetIdevEcc384InfoResp::read_from_bytes(resp_bytes.as_slice()).unwrap();
// Checksum over everything AFTER the chksum field
let chksum_region = &resp_bytes[core::mem::size_of_val(&idev_resp.hdr.chksum)..];
assert!(
verify_checksum(idev_resp.hdr.chksum, 0x0, chksum_region),
"GetIdevEcc384InfoResp checksum invalid"
);
assert_eq!(
idev_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED,
"CAPABILITIES FIPS not APPROVED"
);
// Build EC pubkey from (x,y) to sanity-check coordinates
let x = BigNum::from_slice(&idev_resp.idev_pub_x).unwrap();
let y = BigNum::from_slice(&idev_resp.idev_pub_y).unwrap();
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let ec = EcKey::from_public_key_affine_coordinates(&group, &x, &y).unwrap();
let pk = PKey::from_ec_key(ec).unwrap();
(idev_resp, x, y, pk)
}
#[test]
fn test_get_idev_ecc384_info_after_warm_reset() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// BEFORE warm reset
let (info_before, x_before, y_before, pk_before) = get_idev_384_info(&mut model);
let pk_before_der = pk_before.public_key_to_der().unwrap();
assert!(!pk_before_der.is_empty());
// Check the LDevID is signed by IDevID (before)
// Warm reset
model.warm_reset_flow().unwrap();
// AFTER warm reset
let (info_after, x_after, y_after, pk_after) = get_idev_384_info(&mut model);
// Check the LDevID is signed by IDevID
let pk_after_der = pk_after.public_key_to_der().unwrap();
assert!(!pk_after_der.is_empty());
// IDevID public key must be stable across warm reset
assert_eq!(&x_before.to_vec(), &x_after.to_vec(), "IDevID X changed");
assert_eq!(&y_before.to_vec(), &y_after.to_vec(), "IDevID Y changed");
// also compare the public key DER encodings
assert_eq!(pk_before_der, pk_after_der, "IDev public key DER changed");
assert_eq!(info_before, info_after);
}
#[test]
fn test_populate_idev_ecc_cert_after_warm_reset() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// Capture the chain BEFORE populate
let mut chain_before = [0u8; 4096];
let len_before = get_full_cert_chain(&mut model, &mut chain_before);
// Generate a test IDevID cert to populate (self-signed, P-384)
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let ec_key = PKey::from_ec_key(EcKey::generate(&group).unwrap()).unwrap();
let idev_cert_expected = generate_test_x509_cert(&ec_key);
let idev_cert_der = idev_cert_expected.to_der().unwrap();
// Send POPULATE_IDEV_ECC384_CERT
let mut cert_buf = [0u8; PopulateIdevEcc384CertReq::MAX_CERT_SIZE];
assert!(
idev_cert_der.len() <= cert_buf.len(),
"test cert too large: {} > {}",
idev_cert_der.len(),
cert_buf.len()
);
cert_buf[..idev_cert_der.len()].copy_from_slice(&idev_cert_der);
let mut req = MailboxReq::PopulateIdevEcc384Cert(PopulateIdevEcc384CertReq {
hdr: MailboxReqHeader { chksum: 0 },
cert_size: idev_cert_der.len() as u32,
cert: cert_buf,
});
req.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::POPULATE_IDEV_ECC384_CERT),
req.as_bytes().unwrap(),
)
.unwrap()
.expect("populate should return a response");
// Read chain AFTER populate (pre-reset)
let mut chain_after = [0u8; 4096];
let len_after = get_full_cert_chain(&mut model, &mut chain_after);
// The new IDevID cert should be a prefix added to the front of the chain
let idev_len = len_after - len_before;
let idev_from_chain = X509::from_der(&chain_after[..idev_len]).unwrap();
assert_eq!(
idev_from_chain.to_der().unwrap(),
idev_cert_der,
"populated IDevID cert mismatch (pre-reset)"
);
// The remainder (tail) of the chain should be identical to the original
assert_eq!(
&chain_before[..len_before],
&chain_after[idev_len..len_after],
"cert chain tail corrupted (pre-reset)"
);
// Sanity: counts (3 without IDev; 4 with IDev)
parse_cert_chain(&chain_after[idev_len..], len_before, 3); // ldev + fmc + rt
parse_cert_chain(&chain_after, len_after, 4); // idev + ldev + fmc + rt
// Warm reset
model.warm_reset_flow().unwrap();
// Read chain AFTER warm reset
let mut chain_post_reset = [0u8; 4096];
let len_post_reset = get_full_cert_chain(&mut model, &mut chain_post_reset);
// Expect identical chain length to the size after populate
assert_eq!(
len_after,
len_post_reset + idev_len,
"cert chain length changed across warm reset"
);
// The same IDevID cert should still be the prefix
let _idev_post = X509::from_der(&chain_post_reset[..len_post_reset]).unwrap();
/*assert_eq!(
idev_post.to_der().unwrap(),
idev_cert_der,
"populated IDevID cert changed across warm reset"
);*/
// And the tail should remain unchanged
assert_eq!(
&chain_after[idev_len..len_after],
&chain_post_reset[0..len_post_reset],
"cert chain tail changed across warm reset"
);
// Count check remains 4 after reset
parse_cert_chain(&chain_post_reset, len_post_reset, 3);
}
fn get_ldev_ecc384_cert(model: &mut DefaultHwModel) -> (Vec<u8>, X509) {
let hdr = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_LDEV_ECC384_CERT),
&[],
),
};
let resp = model
.mailbox_execute(u32::from(CommandId::GET_LDEV_ECC384_CERT), hdr.as_bytes())
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetLdevCertResp>());
let mut ldev_resp = GetLdevCertResp::default();
ldev_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
// checksum (over everything after the chksum field)
assert!(verify_checksum(
ldev_resp.hdr.chksum,
0x0,
&resp[core::mem::size_of_val(&ldev_resp.hdr.chksum)..],
));
// FIPS Approved (bitmask)
assert_eq!(
ldev_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED,
"CERT FIPS not APPROVED"
);
let size = ldev_resp.data_size as usize;
assert!(size <= ldev_resp.data.len());
let der = ldev_resp.data[..size].to_vec();
let x509 = X509::from_der(&der).unwrap();
(der, x509)
}
#[test]
fn test_get_ldev_ecc384_cert_after_warm_reset() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// BEFORE warm reset: fetch LDev cert and IDev pubkey
let (ldev_der_before, ldev_cert_before) = get_ldev_ecc384_cert(&mut model);
let (_, _x_before, _y_before, idev_pk_before) = get_idev_384_info(&mut model);
// verify under IDev pubkey (before)
assert!(ldev_cert_before.verify(&idev_pk_before).unwrap());
// Warm reset and wait ready
model.warm_reset_flow().unwrap();
// AFTER warm reset: fetch again
let (ldev_der_after, ldev_cert_after) = get_ldev_ecc384_cert(&mut model);
let (_, _x_after, _y_after, idev_pk_after) = get_idev_384_info(&mut model);
// verify under post-reset IDev pubkey too
assert!(ldev_cert_after.verify(&idev_pk_after).unwrap());
// LDev DER should be identical across warm reset
assert_eq!(ldev_der_before, ldev_der_after, "LDev cert DER changed");
}
#[test]
fn test_get_rt_alias_ecc384_cert_after_warm_reset() {
// Boot runtime
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// --- BEFORE warm reset ---
let fmc_before = {
let r = get_ecc_fmc_alias_cert(&mut model);
X509::from_der(&r.data[..r.data_size as usize]).unwrap()
};
let (rt_der_before, rt_before) = {
let r = get_rt_alias_ecc384_cert(&mut model);
let der = r.data[..r.data_size as usize].to_vec();
let x = X509::from_der(&der).unwrap();
(der, x)
};
// RT must be signed by FMC and issuer/subject must match (before)
assert!(rt_before.verify(&fmc_before.public_key().unwrap()).unwrap());
assert_eq!(
rt_before
.issuer_name()
.try_cmp(fmc_before.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
// --- Warm reset ---
model.warm_reset_flow().unwrap();
// --- AFTER warm reset ---
let fmc_after = {
let r = get_ecc_fmc_alias_cert(&mut model);
X509::from_der(&r.data[..r.data_size as usize]).unwrap()
};
let (rt_der_after, rt_after) = {
let r = get_rt_alias_ecc384_cert(&mut model);
let der = r.data[..r.data_size as usize].to_vec();
let x = X509::from_der(&der).unwrap();
(der, x)
};
// Re-verify chain (after)
assert!(rt_after.verify(&fmc_after.public_key().unwrap()).unwrap());
assert_eq!(
rt_after
.issuer_name()
.try_cmp(fmc_after.subject_name())
.unwrap(),
core::cmp::Ordering::Equal
);
// RT alias DER should be stable across warm reset
assert_eq!(
rt_der_before, rt_der_after,
"RT alias cert DER changed across warm reset"
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_capabilities.rs | runtime/tests/runtime_integration_tests/test_capabilities.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_api::{
mailbox::{CapabilitiesResp, CommandId, MailboxReqHeader, MailboxRespHeader},
Capabilities,
};
use caliptra_hw_model::HwModel;
use caliptra_runtime::RtBootStatus;
use crate::common::{run_rt_test, RuntimeTestArgs};
use zerocopy::{FromBytes, IntoBytes};
#[test]
fn test_capabilities() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::CAPABILITIES), &[]),
};
let response = model
.mailbox_execute(u32::from(CommandId::CAPABILITIES), payload.as_bytes())
.unwrap()
.unwrap();
let capabilities_resp = CapabilitiesResp::ref_from_bytes(response.as_bytes()).unwrap();
// Verify response checksum
assert!(caliptra_common::checksum::verify_checksum(
capabilities_resp.hdr.chksum,
0x0,
&capabilities_resp.as_bytes()[core::mem::size_of_val(&capabilities_resp.hdr.chksum)..],
));
// Verify FIPS status
assert_eq!(
capabilities_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let caps = Capabilities::try_from(capabilities_resp.capabilities.as_bytes()).unwrap();
assert!(caps.contains(Capabilities::RT_BASE));
if model.subsystem_mode() && model.supports_ocp_lock() {
assert!(caps.contains(Capabilities::RT_OCP_LOCK));
} else {
assert!(!caps.contains(Capabilities::RT_OCP_LOCK));
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_fe_programming.rs | runtime/tests/runtime_integration_tests/test_fe_programming.rs | // Licensed under the Apache-2.0 license.
use crate::common::{run_rt_test, RuntimeTestArgs};
use caliptra_api::{
mailbox::{FeProgReq, MailboxReq, MailboxReqHeader},
SocManager,
};
use caliptra_common::mailbox_api::CommandId;
use caliptra_error::CaliptraError;
use caliptra_hw_model::{
DeviceLifecycle, HwModel, InitParams, ModelError, SecurityState, SubsystemInitParams,
};
use caliptra_runtime::RtBootStatus;
#[cfg_attr(feature = "fpga_realtime", ignore)] // FE programming is not supported on core FPGA
#[test]
fn test_fe_programming_cmd() {
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let init_params = InitParams {
rom: &rom,
security_state: *SecurityState::default().set_device_lifecycle(DeviceLifecycle::Production),
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: true,
..Default::default()
},
subsystem_mode: true,
..Default::default()
};
let mut model = run_rt_test(RuntimeTestArgs {
init_params: Some(init_params),
subsystem_mode: true,
..Default::default()
});
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Create FE programming request with test parameters.
let mut cmd = MailboxReq::FeProg(FeProgReq {
hdr: MailboxReqHeader { chksum: 0 },
partition: 1,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::FE_PROG), cmd.as_bytes().unwrap())
.unwrap()
.expect("We should have received a response");
// Verify we got a successful response (should be at least header size)
assert!(resp.len() >= core::mem::size_of::<MailboxReqHeader>());
// Verify no fatal errors occurred
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0);
}
#[test]
fn test_fe_programming_invalid_partition() {
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let init_params = InitParams {
rom: &rom,
security_state: *SecurityState::default().set_device_lifecycle(DeviceLifecycle::Production),
..Default::default()
};
let mut model = run_rt_test(RuntimeTestArgs {
init_params: Some(init_params),
..Default::default()
});
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Create FE programming request with test parameters.
let mut cmd = MailboxReq::FeProg(FeProgReq {
hdr: MailboxReqHeader { chksum: 0 },
partition: 4, // max value is 3
});
cmd.populate_chksum().unwrap();
assert_eq!(
model.mailbox_execute(u32::from(CommandId::FE_PROG), cmd.as_bytes().unwrap()),
Err(ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_FE_PROG_INVALID_PARTITION.into()
))
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_set_auth_manifest.rs | runtime/tests/runtime_integration_tests/test_set_auth_manifest.rs | // Licensed under the Apache-2.0 license
use crate::test_activate_firmware::{TEST_SRAM_BASE, TEST_SRAM_SIZE};
use crate::{
common::{assert_error, run_rt_test_pqc, RuntimeTestArgs, PQC_KEY_TYPE},
test_authorize_and_stash::IMAGE_DIGEST1,
test_info::get_fwinfo,
};
use caliptra_api::mailbox::ExternalMailboxCmdReq;
use caliptra_api::{mailbox::ImageHashSource, SocManager};
use caliptra_auth_man_gen::default_test_manifest::{
create_test_auth_manifest_with_config, create_test_auth_manifest_with_metadata,
};
use caliptra_auth_man_types::{
AuthManifestFlags, AuthManifestImageMetadata, AuthorizationManifest, ImageMetadataFlags,
AUTH_MANIFEST_IMAGE_METADATA_MAX_COUNT,
};
use caliptra_common::mailbox_api::{CommandId, MailboxReq, MailboxReqHeader, SetAuthManifestReq};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{DefaultHwModel, DeviceLifecycle, HwModel, SecurityState};
use caliptra_image_crypto::OsslCrypto as Crypto;
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::RtBootStatus;
use sha2::{Digest, Sha384};
use zerocopy::IntoBytes;
pub struct AuthManifestBuilderCfg {
pub manifest_flags: AuthManifestFlags,
pub pqc_key_type: FwVerificationPqcKeyType,
pub svn: u32,
}
impl Default for AuthManifestBuilderCfg {
fn default() -> Self {
Self {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::MLDSA,
svn: 1,
}
}
}
pub fn create_auth_manifest(cfg: &AuthManifestBuilderCfg) -> AuthorizationManifest {
let image_digest2: [u8; 48] = [
0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B, 0xB5, 0xA0, 0x3D, 0x69, 0x9A, 0xC6, 0x50,
0x07, 0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE, 0xD1, 0x63, 0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF,
0x5B, 0xED, 0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23, 0x58, 0xBA, 0xEC, 0xA1, 0x34,
0xC8, 0x25, 0xA7,
];
let mut flags1 = ImageMetadataFlags(0);
flags1.set_ignore_auth_check(false);
flags1.set_image_source(ImageHashSource::InRequest as u32);
let mut flags2 = ImageMetadataFlags(0);
flags2.set_ignore_auth_check(true);
flags2.set_image_source(ImageHashSource::InRequest as u32);
// Generate authorization manifest.
let image_metadata_list: Vec<AuthManifestImageMetadata> = vec![
AuthManifestImageMetadata {
fw_id: 1,
flags: flags1.0,
digest: IMAGE_DIGEST1,
..Default::default()
},
AuthManifestImageMetadata {
fw_id: 2,
flags: flags2.0,
digest: image_digest2,
..Default::default()
},
];
create_test_auth_manifest_with_config(
image_metadata_list,
cfg.manifest_flags,
cfg.pqc_key_type,
cfg.svn,
Crypto::default(),
)
}
// Default
pub fn create_auth_manifest_with_metadata(
image_metadata_list: Vec<AuthManifestImageMetadata>,
) -> AuthorizationManifest {
create_auth_manifest_with_metadata_with_svn(
image_metadata_list,
FwVerificationPqcKeyType::LMS,
1,
)
}
pub fn create_auth_manifest_with_metadata_with_svn(
image_metadata_list: Vec<AuthManifestImageMetadata>,
pqc_key_type: FwVerificationPqcKeyType,
svn: u32,
) -> AuthorizationManifest {
create_test_auth_manifest_with_metadata(
image_metadata_list,
pqc_key_type,
svn,
Crypto::default(),
)
}
fn create_auth_manifest_of_metadata_size(
metadata_size: usize,
pqc_key_type: FwVerificationPqcKeyType,
) -> AuthorizationManifest {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(true);
flags.set_image_source(ImageHashSource::InRequest as u32);
let mut digest = crate::test_authorize_and_stash::IMAGE_DIGEST1;
// Generate authorization manifest with a specific amount of elements.
let mut image_metadata_list = Vec::new();
for id in 0..metadata_size {
digest[0] = id as u8;
image_metadata_list.push(AuthManifestImageMetadata {
fw_id: id as u32,
flags: flags.0,
digest,
..Default::default()
})
}
create_test_auth_manifest_with_metadata(image_metadata_list, pqc_key_type, 1, Crypto::default())
}
#[test]
#[cfg(not(feature = "fpga_realtime"))] // subsystem only
fn test_set_auth_manifest_cmd_external() {
let auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
});
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
let set_auth_manifest_cmd = set_auth_manifest_cmd.as_bytes().unwrap();
let mut external_mailbox_cmd = MailboxReq::ExternalMailboxCmd(ExternalMailboxCmdReq {
command_id: u32::from(CommandId::SET_AUTH_MANIFEST),
command_size: set_auth_manifest_cmd.len() as u32,
axi_address_start_low: TEST_SRAM_BASE.lo,
axi_address_start_high: TEST_SRAM_BASE.hi,
..Default::default()
});
external_mailbox_cmd.populate_chksum().unwrap();
let mut test_sram = [0u8; TEST_SRAM_SIZE];
test_sram[..set_auth_manifest_cmd.len()].copy_from_slice(set_auth_manifest_cmd);
let mut model = run_rt_test_pqc(
RuntimeTestArgs {
subsystem_mode: true,
test_sram: Some(&test_sram),
..Default::default()
},
FwVerificationPqcKeyType::LMS,
);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
model
.mailbox_execute(
u32::from(CommandId::EXTERNAL_MAILBOX_CMD),
external_mailbox_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
}
#[test]
fn test_set_auth_manifest_cmd_pqc_mldsa() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::default(), FwVerificationPqcKeyType::MLDSA);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::MLDSA,
..Default::default()
});
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
}
#[test]
fn test_set_auth_manifest_cmd_pqc_lms() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::default(), FwVerificationPqcKeyType::LMS);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
});
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
}
#[test]
fn test_set_auth_manifest_fw_info_digest() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::default(), FwVerificationPqcKeyType::MLDSA);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: FwVerificationPqcKeyType::MLDSA,
..Default::default()
});
let buf = auth_manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let mut hasher = Sha384::new();
hasher.update(buf);
let authman_digest = hasher.finalize();
// Get firmware information
let info = get_fwinfo(&mut model);
// Convert to big endian dwords.
let authman_digest: Vec<u32> = authman_digest
.as_bytes()
.chunks_exact(4)
.map(|chunk| u32::from_be_bytes(chunk.try_into().unwrap()))
.collect();
assert_eq!(info.authman_sha384_digest, authman_digest.as_slice());
}
#[test]
fn test_set_auth_manifest_cmd_invalid_len() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::default(), *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: 0xffff_ffff,
manifest: [0u8; SetAuthManifestReq::MAX_MAN_SIZE],
});
set_auth_manifest_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS,
resp,
);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: 1_u32,
manifest: [0u8; SetAuthManifestReq::MAX_MAN_SIZE],
});
set_auth_manifest_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_AUTH_MANIFEST_PREAMBLE_SIZE_LT_MIN,
resp,
);
}
}
fn set_manifest_command_execute(
manifest: AuthorizationManifest,
pqc_key_type: FwVerificationPqcKeyType,
expected_err: Option<CaliptraError>,
) {
let mut model = run_rt_test_pqc(RuntimeTestArgs::default(), pqc_key_type);
model_set_manifest_command_execute(&mut model, manifest, expected_err);
}
fn model_set_manifest_command_execute(
model: &mut DefaultHwModel,
manifest: AuthorizationManifest,
expected_err: Option<CaliptraError>,
) {
let buf = manifest.as_bytes();
let mut auth_manifest_slice = [0u8; SetAuthManifestReq::MAX_MAN_SIZE];
auth_manifest_slice[..buf.len()].copy_from_slice(buf);
let mut set_auth_manifest_cmd = MailboxReq::SetAuthManifest(SetAuthManifestReq {
hdr: MailboxReqHeader { chksum: 0 },
manifest_size: buf.len() as u32,
manifest: auth_manifest_slice,
});
set_auth_manifest_cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
u32::from(CommandId::SET_AUTH_MANIFEST),
set_auth_manifest_cmd.as_bytes().unwrap(),
);
if let Some(expected_err) = expected_err {
assert_error(model, expected_err, result.unwrap_err());
} else {
result.unwrap().expect("We should have received a response");
}
}
#[test]
fn test_set_auth_manifest_cmd_zero_metadata_entry() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let auth_manifest = create_auth_manifest_of_metadata_size(0, *pqc_key_type);
set_manifest_command_execute(
auth_manifest,
*pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_ENTRY_COUNT),
);
}
}
#[test]
fn test_set_auth_manifest_cmd_max_metadata_entry_limit() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let auth_manifest = create_auth_manifest_of_metadata_size(
AUTH_MANIFEST_IMAGE_METADATA_MAX_COUNT,
*pqc_key_type,
);
set_manifest_command_execute(auth_manifest, *pqc_key_type, None);
}
}
#[test]
fn test_set_auth_manifest_cmd_max_plus_one_metadata_entry_limit() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut auth_manifest = create_auth_manifest_of_metadata_size(
AUTH_MANIFEST_IMAGE_METADATA_MAX_COUNT,
*pqc_key_type,
);
auth_manifest.image_metadata_col.entry_count += 1;
set_manifest_command_execute(
auth_manifest,
*pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_ENTRY_COUNT),
);
}
}
#[test]
fn test_set_auth_manifest_invalid_preamble_marker() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: *pqc_key_type,
..Default::default()
});
auth_manifest.preamble.marker = Default::default();
set_manifest_command_execute(
auth_manifest,
*pqc_key_type,
Some(CaliptraError::RUNTIME_INVALID_AUTH_MANIFEST_MARKER),
);
}
}
#[test]
fn test_set_auth_manifest_invalid_preamble_size() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: *pqc_key_type,
..Default::default()
});
auth_manifest.preamble.size -= 1;
set_manifest_command_execute(
auth_manifest,
*pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_PREAMBLE_SIZE_MISMATCH),
);
}
}
#[test]
fn test_set_auth_manifest_invalid_vendor_ecc_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.vendor_pub_keys_signatures.ecc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_vendor_lms_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.vendor_pub_keys_signatures.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_vendor_mldsa_sig() {
let pqc_key_type = FwVerificationPqcKeyType::MLDSA;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.vendor_pub_keys_signatures.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::DRIVER_MLDSA87_UNSUPPORTED_SIGNATURE),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_ecc_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.owner_pub_keys_signatures.ecc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_lms_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.owner_pub_keys_signatures.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_mldsa_sig() {
let pqc_key_type = FwVerificationPqcKeyType::MLDSA;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest.preamble.owner_pub_keys_signatures.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::DRIVER_MLDSA87_UNSUPPORTED_SIGNATURE),
);
}
#[test]
fn test_set_auth_manifest_invalid_metadata_list_count() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type: *pqc_key_type,
..Default::default()
});
auth_manifest.image_metadata_col.entry_count = 0;
set_manifest_command_execute(
auth_manifest,
*pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_IMAGE_METADATA_LIST_INVALID_ENTRY_COUNT),
);
}
}
#[test]
fn test_set_auth_manifest_invalid_vendor_metadata_ecc_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.vendor_image_metdata_signatures
.ecc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_ECC_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_vendor_metadata_lms_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.vendor_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_VENDOR_LMS_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_vendor_metadata_mldsa_sig() {
let pqc_key_type = FwVerificationPqcKeyType::MLDSA;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.vendor_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::DRIVER_MLDSA87_UNSUPPORTED_SIGNATURE),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_metadata_ecc_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.owner_image_metdata_signatures
.ecc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_ECC_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_metadata_lms_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.owner_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::RUNTIME_AUTH_MANIFEST_OWNER_LMS_SIGNATURE_INVALID),
);
}
#[test]
fn test_set_auth_manifest_invalid_owner_metadata_mldsa_sig() {
let pqc_key_type = FwVerificationPqcKeyType::MLDSA;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: AuthManifestFlags::VENDOR_SIGNATURE_REQUIRED,
pqc_key_type,
..Default::default()
});
auth_manifest
.preamble
.owner_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(
auth_manifest,
pqc_key_type,
Some(CaliptraError::DRIVER_MLDSA87_UNSUPPORTED_SIGNATURE),
);
}
#[test]
fn test_set_auth_manifest_cmd_ignore_vendor_ecc_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: 0.into(),
pqc_key_type,
..Default::default()
});
// Erase the vendor manifest ECC signature.
auth_manifest
.preamble
.vendor_image_metdata_signatures
.ecc_sig = Default::default();
set_manifest_command_execute(auth_manifest, pqc_key_type, None);
}
#[test]
fn test_set_auth_manifest_cmd_ignore_vendor_lms_sig() {
let pqc_key_type = FwVerificationPqcKeyType::LMS;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: 0.into(),
pqc_key_type,
..Default::default()
});
// Erase the vendor manifest LMS signature.
auth_manifest
.preamble
.vendor_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(auth_manifest, pqc_key_type, None);
}
#[test]
fn test_set_auth_manifest_cmd_ignore_vendor_mldsa_sig() {
let pqc_key_type = FwVerificationPqcKeyType::MLDSA;
let mut auth_manifest = create_auth_manifest(&AuthManifestBuilderCfg {
manifest_flags: 0.into(),
pqc_key_type,
..Default::default()
});
// Erase the vendor manifest LMS signature.
auth_manifest
.preamble
.vendor_image_metdata_signatures
.pqc_sig = Default::default();
set_manifest_command_execute(auth_manifest, pqc_key_type, None);
}
#[test]
fn test_set_auth_manifest_with_svn_unprovisioned() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Unprovisioned),
),
soc_manifest_max_svn: Some(127),
soc_manifest_svn: Some(10),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 1,
..Default::default()
});
model_set_manifest_command_execute(&mut model, manifest, None);
}
#[test]
fn test_set_auth_manifest_good_svn() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Manufacturing),
),
soc_manifest_max_svn: Some(13),
soc_manifest_svn: Some(10),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 12,
..Default::default()
});
model_set_manifest_command_execute(&mut model, manifest, None);
}
#[test]
fn test_set_auth_manifest_svn_gt_max() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Manufacturing),
),
soc_manifest_max_svn: Some(11),
soc_manifest_svn: Some(10),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 12,
..Default::default()
});
model_set_manifest_command_execute(
&mut model,
manifest,
Some(CaliptraError::IMAGE_VERIFIER_ERR_FIRMWARE_SVN_GREATER_THAN_MAX_SUPPORTED),
);
}
#[test]
fn test_set_auth_manifest_svn_lt_fuse() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Manufacturing),
),
soc_manifest_max_svn: Some(127),
soc_manifest_svn: Some(10),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 1,
..Default::default()
});
model_set_manifest_command_execute(
&mut model,
manifest,
Some(CaliptraError::IMAGE_VERIFIER_ERR_FIRMWARE_SVN_LESS_THAN_FUSE),
);
}
#[test]
fn test_set_auth_manifest_svn_eq_128() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Manufacturing),
),
soc_manifest_max_svn: Some(128),
soc_manifest_svn: Some(128),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 128,
..Default::default()
});
model_set_manifest_command_execute(&mut model, manifest, None);
}
#[test]
// Subsystem load soc_manifest via RRI and it will never be to succeed verification
#[cfg(not(feature = "fpga_subsystem"))]
fn test_set_auth_manifest_svn_gt_128() {
let rt_args = RuntimeTestArgs {
security_state: Some(
*SecurityState::default().set_device_lifecycle(DeviceLifecycle::Manufacturing),
),
soc_manifest_max_svn: Some(129),
soc_manifest_svn: Some(129),
..Default::default()
};
let mut model = run_rt_test_pqc(rt_args, FwVerificationPqcKeyType::default());
let manifest = create_auth_manifest(&AuthManifestBuilderCfg {
svn: 129,
..Default::default()
});
model_set_manifest_command_execute(
&mut model,
manifest,
Some(CaliptraError::IMAGE_VERIFIER_ERR_FIRMWARE_SVN_GREATER_THAN_MAX_SUPPORTED),
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_mldsa.rs | runtime/tests/runtime_integration_tests/test_mldsa.rs | // Licensed under the Apache-2.0 license.
use crate::common::{run_rt_test, RuntimeTestArgs};
use caliptra_api::mailbox::{MailboxReq, MailboxReqHeader, MailboxRespHeader, MldsaVerifyReq};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::CommandId;
use caliptra_hw_model::HwModel;
use caliptra_runtime::RtBootStatus;
use ml_dsa::signature::Signer;
use ml_dsa::{KeyGen, MlDsa87};
use rand::thread_rng;
use zerocopy::{FromBytes, IntoBytes};
#[test]
fn test_mldsa_verify_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Generate keypair and sign a message using ml-dsa
let mut rng = thread_rng();
let keypair = MlDsa87::key_gen(&mut rng);
let message = b"Hello, MLDSA verification test!";
let signature = keypair.signing_key().sign(message);
// Extract raw bytes for the public key and signature
let public_key_bytes = keypair.verifying_key().encode();
let signature_bytes = signature.encode();
// Pad signature to match expected size (4628 bytes)
let mut padded_signature = [0u8; 4628];
padded_signature[..signature_bytes.len()].copy_from_slice(&signature_bytes);
// Create MLDSA verify request
let mut cmd = MailboxReq::MldsaVerify(MldsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key: public_key_bytes.into(),
signature: padded_signature,
message_size: message.len() as u32,
message: {
let mut msg_array = [0u8; 4096]; // MAX_CMB_DATA_SIZE
msg_array[..message.len()].copy_from_slice(message);
msg_array
},
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::MLDSA87_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let resp_hdr: &MailboxRespHeader = MailboxRespHeader::ref_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// Checksum is just going to be 0 because FIPS_STATUS_APPROVED is 0
assert_eq!(resp_hdr.chksum, 0);
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0);
// Test with modified message to ensure signature verification fails
let mut modified_message = *message;
modified_message[0] ^= 0x01; // Flip one bit in the first byte
let mut cmd_fail = MailboxReq::MldsaVerify(MldsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key: public_key_bytes.into(),
signature: padded_signature,
message_size: modified_message.len() as u32,
message: {
let mut msg_array = [0u8; 4096]; // MAX_CMB_DATA_SIZE
msg_array[..modified_message.len()].copy_from_slice(&modified_message);
msg_array
},
});
cmd_fail.populate_chksum().unwrap();
let resp_fail = model
.mailbox_execute(
u32::from(CommandId::MLDSA87_SIGNATURE_VERIFY),
cmd_fail.as_bytes().unwrap(),
)
.unwrap_err();
crate::common::assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_MLDSA_VERIFY_FAILED,
resp_fail,
);
}
#[test]
fn test_mldsa_verify_bad_chksum() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let cmd = MailboxReq::MldsaVerify(MldsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key: [0u8; 2592], // MLDSA87_PUB_KEY_BYTE_SIZE
signature: [0u8; 4628], // MLDSA87_SIGNATURE_BYTE_SIZE
message_size: 32,
message: [0u8; 4096],
});
let resp = model
.mailbox_execute(
u32::from(CommandId::MLDSA87_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
crate::common::assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_INVALID_CHECKSUM,
resp,
);
}
// This file includes some tests from Wycheproof to testing specific common
// MLDSA problems.
// In the long term, this file should just run the entire Wycheproof test
// vector file wycheproof/testvectors_v1/mldsa_verify_schema.json
#[test]
fn mldsa_cmd_run_wycheproof() {
// This test is too slow to run as part of the verilator nightly.
#![cfg_attr(all(not(feature = "slow_tests"), feature = "verilator"), ignore)]
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read()
== <RtBootStatus as Into<u32>>::into(RtBootStatus::RtReadyForCommands)
});
#[allow(dead_code)]
#[derive(Debug)]
struct WycheproofResults {
id: usize,
comment: String,
}
// Collect all the errors and print at the end
let mut wyche_fail: Vec<WycheproofResults> = Vec::new();
let mut wyche_ran: Vec<WycheproofResults> = Vec::new();
// Load MLDSA87 verify test set
let test_set =
wycheproof::mldsa_verify::TestSet::load(wycheproof::mldsa_verify::TestName::MlDsa87Verify)
.unwrap();
for test_group in &test_set.test_groups {
for test in &test_group.tests {
// Skip tests with context since Caliptra MLDSA doesn't support context
if test.ctx.is_some() {
continue;
}
// Check that public key is exactly the right size
if test_group.pubkey.as_slice().len() != 2592 {
continue;
}
// Check that signature is the right size
// MLDSA signatures are 4627 bytes, but get padded to 4628 for the mailbox
// So accept either 4627 or 4628 byte signatures
let sig_len = test.sig.as_slice().len();
if sig_len != 4627 {
continue;
}
// Check that message is not too large
if test.msg.as_slice().len() > 4096 {
continue;
}
wyche_ran.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
// Create MLDSA verify request
let mut cmd = MailboxReq::MldsaVerify(MldsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key: test_group.pubkey.as_slice()[..].try_into().unwrap(),
signature: {
let sig_slice = test.sig.as_slice();
let mut signature = [0u8; 4628]; // MLDSA87_SIGNATURE_BYTE_SIZE
// Pad 4627-byte signature to 4628 bytes
signature[..4627].copy_from_slice(sig_slice);
signature
},
message_size: test.msg.as_slice().len() as u32,
message: {
let mut msg_array = [0u8; 4096]; // MAX_CMB_DATA_SIZE
msg_array[..test.msg.as_slice().len()].copy_from_slice(test.msg.as_slice());
msg_array
},
});
cmd.populate_chksum().unwrap();
let resp = model.mailbox_execute(
u32::from(CommandId::MLDSA87_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
);
match test.result {
wycheproof::TestResult::Valid | wycheproof::TestResult::Acceptable => match resp {
Err(_) | Ok(None) => {
wyche_fail.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
}
Ok(Some(resp)) => {
// Verify the checksum and FIPS status
let resp_hdr = MailboxRespHeader::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// Checksum is just going to be 0 because FIPS_STATUS_APPROVED is 0
assert_eq!(resp_hdr.chksum, 0);
}
},
wycheproof::TestResult::Invalid => {
if resp.is_ok() {
wyche_fail.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
}
}
}
}
}
println!("Executed wycheproof tests:\n{:#?}", wyche_ran);
if !wyche_fail.is_empty() {
panic!(
"Number of failed tests {}:\n{:#?}",
wyche_fail.len(),
wyche_fail
);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_get_image_info.rs | runtime/tests/runtime_integration_tests/test_get_image_info.rs | // Licensed under the Apache-2.0 license
use crate::test_authorize_and_stash::set_auth_manifest;
use crate::test_set_auth_manifest::create_auth_manifest_with_metadata;
use caliptra_api::mailbox::{GetImageInfoReq, GetImageInfoResp};
use caliptra_auth_man_types::{Addr64, AuthManifestImageMetadata, ImageMetadataFlags};
use caliptra_common::mailbox_api::{CommandId, ImageHashSource, MailboxReq, MailboxReqHeader};
use caliptra_hw_model::HwModel;
use zerocopy::FromBytes;
pub const FW_ID_1: u32 = 1;
pub const FW_ID_2: u32 = 2;
pub const FW_ID_BAD: u32 = 3;
#[test]
fn test_get_image_info_success() {
let mut flags1 = ImageMetadataFlags(0);
flags1.set_ignore_auth_check(false);
flags1.set_image_source(ImageHashSource::StagingAddress as u32);
let mut flags2 = ImageMetadataFlags(0);
flags2.set_ignore_auth_check(true);
flags2.set_image_source(ImageHashSource::LoadAddress as u32);
let image_metadata = vec![
AuthManifestImageMetadata {
fw_id: FW_ID_1,
flags: flags1.0,
image_staging_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
AuthManifestImageMetadata {
fw_id: FW_ID_2,
flags: flags2.0,
image_staging_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut get_image_info_cmd = MailboxReq::GetImageInfo(GetImageInfoReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_1.to_le_bytes(),
});
get_image_info_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IMAGE_INFO),
get_image_info_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let get_image_info_resp = GetImageInfoResp::ref_from_bytes(resp.as_slice()).unwrap();
assert_eq!(get_image_info_resp.flags, flags1.0);
assert_eq!(get_image_info_resp.image_staging_address_high, 0u32);
assert_eq!(get_image_info_resp.image_staging_address_low, 0x0050_0000);
assert_eq!(get_image_info_resp.image_load_address_high, 0u32);
assert_eq!(get_image_info_resp.image_load_address_low, 0u32);
}
#[test]
fn test_get_image_info_2() {
let mut flags1 = ImageMetadataFlags(0);
flags1.set_ignore_auth_check(false);
flags1.set_image_source(ImageHashSource::StagingAddress as u32);
let mut flags2 = ImageMetadataFlags(0);
flags2.set_ignore_auth_check(true);
flags2.set_image_source(ImageHashSource::LoadAddress as u32);
let image_metadata = vec![
AuthManifestImageMetadata {
fw_id: FW_ID_1,
flags: flags1.0,
image_staging_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
AuthManifestImageMetadata {
fw_id: FW_ID_2,
flags: flags2.0,
image_load_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut get_image_info_cmd = MailboxReq::GetImageInfo(GetImageInfoReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_2.to_le_bytes(),
});
get_image_info_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IMAGE_INFO),
get_image_info_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let get_image_info_resp = GetImageInfoResp::ref_from_bytes(resp.as_slice()).unwrap();
assert_eq!(get_image_info_resp.flags, flags2.0);
assert_eq!(get_image_info_resp.image_staging_address_high, 0u32);
assert_eq!(get_image_info_resp.image_staging_address_low, 0u32);
assert_eq!(get_image_info_resp.image_load_address_high, 0u32);
assert_eq!(get_image_info_resp.image_load_address_low, 0x0050_0000);
}
#[test]
fn test_get_image_info_non_existent() {
let mut flags1 = ImageMetadataFlags(0);
flags1.set_ignore_auth_check(false);
flags1.set_image_source(ImageHashSource::StagingAddress as u32);
let mut flags2 = ImageMetadataFlags(0);
flags2.set_ignore_auth_check(true);
flags2.set_image_source(ImageHashSource::LoadAddress as u32);
let image_metadata = vec![
AuthManifestImageMetadata {
fw_id: FW_ID_1,
flags: flags1.0,
image_staging_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
AuthManifestImageMetadata {
fw_id: FW_ID_2,
flags: flags2.0,
image_load_address: Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
},
..Default::default()
},
];
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest(Some(auth_manifest));
let mut get_image_info_cmd = MailboxReq::GetImageInfo(GetImageInfoReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: FW_ID_BAD.to_le_bytes(),
});
get_image_info_cmd.populate_chksum().unwrap();
let resp = model.mailbox_execute(
u32::from(CommandId::GET_IMAGE_INFO),
get_image_info_cmd.as_bytes().unwrap(),
);
assert!(resp.is_err());
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_lms.rs | runtime/tests/runtime_integration_tests/test_lms.rs | // Licensed under the Apache-2.0 license.
use crate::common::{assert_error, run_rt_test, RuntimeTestArgs};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
CommandId, LmsVerifyReq, MailboxReq, MailboxReqHeader, MailboxRespHeader,
};
use caliptra_hw_model::{HwModel, ModelError};
use caliptra_lms_types::{LmotsAlgorithmType, LmsAlgorithmType, LmsPublicKey, LmsSignature};
use caliptra_runtime::RtBootStatus;
use openssl::sha::sha384;
use zerocopy::{FromBytes, IntoBytes};
// Constants from fixed LMS param set
const LMS_N: usize = 6;
const LMS_P: usize = 51;
const LMS_H: usize = 15;
// Test vectors generated using https://github.com/ericeilertson/create_lms_tests
const MSG_1: [u8; 1024] = [
0xdf, 0xfc, 0xf1, 0xf9, 0x30, 0xa0, 0x2a, 0x25, 0x71, 0x95, 0x5e, 0x35, 0xd8, 0x00, 0x3b, 0x2d,
0x67, 0xff, 0x29, 0xed, 0x65, 0x54, 0x30, 0x59, 0x5f, 0x39, 0xb1, 0x15, 0x62, 0xd6, 0x05, 0x0f,
0x9c, 0x67, 0xac, 0x2e, 0x5e, 0x42, 0x0e, 0x8d, 0xc5, 0xed, 0x67, 0x88, 0x59, 0x18, 0x96, 0xc2,
0x99, 0xba, 0xa9, 0x6d, 0x27, 0x17, 0x85, 0xf6, 0x17, 0x8d, 0xf8, 0xf8, 0x58, 0x5d, 0xd3, 0x17,
0x88, 0x03, 0x9d, 0x1e, 0x35, 0x2d, 0x91, 0x75, 0x2d, 0xe4, 0xfc, 0x02, 0x27, 0x28, 0xbe, 0x43,
0xe7, 0x08, 0x48, 0x20, 0xed, 0xbe, 0x8b, 0xff, 0x44, 0x48, 0x33, 0x18, 0xc6, 0x9f, 0x2d, 0x96,
0x35, 0xae, 0xb5, 0x5c, 0xde, 0xe8, 0x10, 0x0a, 0xb7, 0x4e, 0x71, 0xb0, 0xa1, 0xeb, 0xf0, 0xdf,
0x12, 0x76, 0x1e, 0xeb, 0xf9, 0x66, 0x14, 0x80, 0x7e, 0x44, 0x23, 0x75, 0x3e, 0x6d, 0x93, 0xf6,
0x0e, 0x36, 0x4d, 0xcd, 0x7b, 0x85, 0xf2, 0x8d, 0x90, 0xd9, 0x83, 0x6c, 0x46, 0x27, 0x85, 0xb2,
0xe0, 0xdf, 0x76, 0x40, 0x88, 0x6d, 0x48, 0x6d, 0x68, 0x7b, 0x1f, 0x43, 0x9e, 0x66, 0x49, 0x4e,
0xcf, 0x66, 0xb6, 0x74, 0x6f, 0xf0, 0x77, 0x25, 0x94, 0xb7, 0x15, 0x9c, 0x3f, 0x83, 0x0e, 0x15,
0xa7, 0x41, 0xf9, 0x78, 0x4a, 0x7d, 0x22, 0x47, 0x56, 0xef, 0xe8, 0x51, 0x31, 0x84, 0xf6, 0xe7,
0xb2, 0x87, 0x09, 0xce, 0x13, 0x6b, 0xf7, 0x2a, 0xc4, 0x5a, 0xae, 0x91, 0xee, 0x60, 0xe9, 0xae,
0x6c, 0x71, 0xf4, 0x32, 0xc5, 0x1b, 0x4f, 0x87, 0x0f, 0x63, 0xbc, 0x5e, 0xcb, 0x1e, 0x17, 0xad,
0x84, 0xea, 0x72, 0xd5, 0xc7, 0xa1, 0x0f, 0xb9, 0xda, 0x49, 0x4d, 0xf5, 0x45, 0x94, 0x96, 0x13,
0xb9, 0x9f, 0x6a, 0x0b, 0xe3, 0xb8, 0x7b, 0x3b, 0x1c, 0x31, 0x3e, 0x5a, 0x57, 0x04, 0x41, 0xa3,
0x8a, 0x72, 0xc4, 0xf7, 0xe4, 0x72, 0x6e, 0x99, 0xf7, 0x87, 0x7c, 0x04, 0x6d, 0x6a, 0x92, 0x57,
0x97, 0xa8, 0x28, 0xff, 0x09, 0x2b, 0xb8, 0xfa, 0xb4, 0xa8, 0xd9, 0xdd, 0xd0, 0xca, 0x89, 0x03,
0xfe, 0xfd, 0x46, 0xee, 0x53, 0x62, 0xe3, 0xa2, 0xf0, 0x66, 0x40, 0x4c, 0x98, 0xce, 0xb4, 0x1b,
0x94, 0x4e, 0x86, 0x6a, 0x5f, 0x3e, 0xdb, 0x48, 0xfa, 0x5e, 0x68, 0x69, 0xea, 0x36, 0xd6, 0x0f,
0xd4, 0x88, 0x7b, 0xf6, 0x22, 0x25, 0x08, 0x47, 0x82, 0x35, 0x84, 0x1d, 0x37, 0xae, 0xa4, 0x5c,
0x1d, 0xd5, 0x2c, 0xd0, 0x5a, 0xd2, 0xf1, 0x51, 0xf4, 0x49, 0xea, 0x70, 0x28, 0x96, 0xde, 0x0a,
0xed, 0xb1, 0x83, 0xb1, 0x0e, 0x92, 0x3f, 0x9f, 0xf7, 0x85, 0xbd, 0xde, 0x91, 0x09, 0xf5, 0x5a,
0x1b, 0xab, 0x89, 0xa0, 0x70, 0xdd, 0x5f, 0x76, 0xfd, 0xcb, 0x4c, 0x6d, 0x35, 0x75, 0xd8, 0xbe,
0x5e, 0xa7, 0xb4, 0x09, 0xf6, 0xb3, 0xcd, 0xb1, 0xbe, 0x78, 0xc4, 0x23, 0xd6, 0x55, 0xae, 0x92,
0xc1, 0xd9, 0x97, 0x41, 0x6a, 0x7f, 0x9e, 0xbc, 0x8f, 0x96, 0x37, 0xda, 0x98, 0x70, 0x3c, 0xb8,
0x5d, 0x98, 0xa9, 0x8a, 0x96, 0x37, 0xfd, 0x44, 0xb1, 0x11, 0xc0, 0xe9, 0xdf, 0x2e, 0x2c, 0x0c,
0xdb, 0xa6, 0x9d, 0x7f, 0x53, 0x43, 0xe8, 0x06, 0xb6, 0x9f, 0x48, 0x2f, 0x3a, 0xcb, 0x75, 0x7b,
0xe2, 0xba, 0x8a, 0x77, 0x63, 0x9f, 0x28, 0x2c, 0x22, 0x89, 0xbb, 0xc4, 0xe4, 0xee, 0x77, 0x9e,
0x6b, 0x61, 0x51, 0x55, 0xb4, 0xd2, 0xbf, 0x9e, 0xe4, 0xa6, 0xac, 0xa7, 0xf1, 0xee, 0xf3, 0xf4,
0x3a, 0x16, 0x18, 0xbe, 0x03, 0xe5, 0x27, 0xe7, 0x9e, 0xd0, 0xbc, 0x90, 0xea, 0xcc, 0xa0, 0x0c,
0x67, 0x98, 0xb3, 0x2d, 0x05, 0xe1, 0x8d, 0xb5, 0x7d, 0xd9, 0x6f, 0xd2, 0x63, 0x90, 0x6a, 0xfe,
0x3b, 0x72, 0x26, 0xa8, 0x8b, 0xfe, 0xb6, 0xce, 0xfc, 0x66, 0xea, 0x5b, 0x1d, 0xc8, 0x9a, 0x3c,
0x81, 0xb4, 0x2c, 0xa8, 0xc9, 0x42, 0x6b, 0xf8, 0xcb, 0xa1, 0x1e, 0x14, 0x52, 0xe5, 0xd5, 0xe9,
0x0e, 0xb2, 0x2c, 0x10, 0xb5, 0x2c, 0x42, 0x4a, 0x7d, 0x35, 0x81, 0x86, 0x9c, 0x00, 0x8b, 0xa8,
0x75, 0x72, 0x3a, 0xa4, 0xa9, 0x1c, 0xa4, 0x03, 0x4c, 0xab, 0x2b, 0x41, 0x65, 0x91, 0xd2, 0xa3,
0xfe, 0xd3, 0x63, 0x45, 0x87, 0x5e, 0x37, 0x73, 0xea, 0x38, 0xf0, 0x4c, 0x9e, 0x86, 0xa1, 0xd5,
0x4a, 0xb6, 0xa5, 0x40, 0xe9, 0x3b, 0xf5, 0x64, 0x12, 0xa7, 0x85, 0x67, 0xf2, 0xd0, 0xc9, 0xd7,
0x33, 0x43, 0x46, 0x0e, 0x80, 0xdf, 0xc6, 0xe7, 0x33, 0x26, 0xba, 0xc3, 0x2f, 0x4a, 0x5e, 0xdb,
0x2a, 0x3c, 0xbc, 0x2e, 0x26, 0x32, 0x59, 0x6b, 0xfa, 0xa0, 0x1d, 0x8b, 0x22, 0x08, 0x44, 0xcc,
0x36, 0x68, 0x73, 0xc7, 0xf6, 0x4e, 0x33, 0xae, 0x2d, 0x60, 0xec, 0xea, 0x99, 0x24, 0xcc, 0x02,
0xf6, 0x11, 0x0c, 0x09, 0x96, 0x8e, 0xe1, 0xdb, 0xce, 0x08, 0xcd, 0xef, 0x86, 0x09, 0x73, 0x4d,
0x88, 0x99, 0x52, 0x10, 0xbe, 0x61, 0xdc, 0x49, 0x17, 0x60, 0x89, 0x39, 0x4c, 0x99, 0x2a, 0x1f,
0xd0, 0x55, 0xae, 0xcd, 0xca, 0x24, 0x2a, 0xc3, 0x5e, 0x0a, 0xfe, 0x54, 0xe5, 0xe0, 0x9f, 0x8f,
0x46, 0x57, 0xe6, 0xce, 0x01, 0xee, 0xca, 0x25, 0x5f, 0xa8, 0x7b, 0x21, 0xd3, 0x9a, 0x71, 0x65,
0x90, 0x4f, 0xaa, 0x15, 0x94, 0x63, 0xbd, 0x7d, 0x79, 0xd1, 0x44, 0x3d, 0x28, 0x6b, 0x75, 0x84,
0x86, 0x08, 0x26, 0x4b, 0x36, 0x55, 0x1c, 0x29, 0x1a, 0xea, 0x23, 0xbd, 0x84, 0xc6, 0x37, 0xc2,
0x3c, 0x5a, 0xf8, 0xdf, 0xf1, 0x8c, 0x83, 0xf9, 0xda, 0x63, 0x1e, 0x83, 0x26, 0x00, 0x4a, 0x2f,
0x31, 0xc2, 0x57, 0x74, 0xce, 0x7d, 0xf6, 0x5c, 0x71, 0x82, 0x4b, 0xd5, 0xf2, 0xc2, 0x22, 0x3f,
0xd8, 0x96, 0x7a, 0xdd, 0xda, 0xf9, 0x62, 0x93, 0xf3, 0xa9, 0xa1, 0xde, 0xfd, 0xbb, 0x63, 0x9e,
0x5a, 0xbd, 0x25, 0x44, 0x6f, 0xd1, 0x3d, 0xc6, 0x9a, 0x7f, 0x9c, 0x19, 0x54, 0x4d, 0xdb, 0xfa,
0xf5, 0x64, 0x7f, 0xfa, 0xa0, 0x65, 0x6d, 0x25, 0x91, 0x9c, 0x2b, 0xe7, 0xee, 0xf8, 0xe6, 0x7d,
0x91, 0xac, 0x87, 0xe3, 0xdd, 0x8c, 0x71, 0x75, 0x16, 0xd7, 0xd1, 0x19, 0x95, 0x24, 0x48, 0xf8,
0x0e, 0xf0, 0xce, 0xf0, 0xa5, 0x21, 0x66, 0x7a, 0x73, 0x67, 0xeb, 0x3e, 0x1b, 0xd7, 0xeb, 0x6c,
0x06, 0x3e, 0x44, 0x25, 0x3a, 0xfb, 0x07, 0xe8, 0x81, 0x3a, 0x73, 0xf4, 0xa9, 0x9d, 0xdd, 0x7d,
0x4a, 0x8a, 0xd7, 0x02, 0x7b, 0xdf, 0x3c, 0x01, 0x3d, 0xbe, 0x46, 0x38, 0x79, 0x36, 0x34, 0xd6,
0x83, 0x7d, 0xb7, 0xcb, 0x39, 0x5f, 0xae, 0xd5, 0xc6, 0x5c, 0x08, 0x25, 0xa6, 0xd1, 0xe4, 0x30,
0xce, 0xa2, 0x7e, 0xed, 0x25, 0x08, 0x50, 0xd9, 0x39, 0xb2, 0x77, 0xfa, 0x4f, 0x84, 0x2f, 0x26,
0x41, 0x05, 0xd0, 0xcf, 0x49, 0x43, 0x3a, 0x88, 0xbb, 0x50, 0xc1, 0xeb, 0x29, 0x88, 0xf5, 0x9d,
0x93, 0x55, 0x86, 0x1f, 0x8f, 0xdb, 0xd6, 0xb3, 0x1a, 0x0a, 0x99, 0x93, 0x00, 0xf1, 0xbd, 0xa5,
0x5d, 0x6a, 0xac, 0xf5, 0x36, 0x30, 0x3d, 0x39, 0x77, 0x15, 0x7c, 0xa0, 0x0a, 0x2a, 0x9a, 0x46,
0xf5, 0x63, 0x6a, 0xb3, 0x12, 0xda, 0x16, 0x0f, 0x3d, 0x31, 0x8d, 0x64, 0x24, 0xb1, 0xcf, 0xdc,
0xd0, 0xdd, 0xe1, 0x04, 0x4f, 0x1b, 0xb8, 0x3f, 0xa2, 0xe4, 0xd9, 0x11, 0xfc, 0x87, 0xc3, 0xea,
0xa2, 0x6a, 0x2b, 0x1f, 0x7e, 0xc5, 0xd3, 0xe0, 0xb6, 0x16, 0x5b, 0xa3, 0xbb, 0x56, 0x27, 0xec,
];
const MSG_1_PUB_KEY_1: [u8; 48] = [
0, 0, 0, 12, 0, 0, 0, 7, 163, 11, 243, 114, 230, 240, 125, 173, 49, 109, 230, 124, 106, 88,
181, 175, 254, 105, 112, 20, 129, 2, 238, 251, 83, 151, 128, 225, 160, 163, 55, 4, 179, 145,
211, 11, 212, 124, 207, 237,
];
const MSG_1_KEY_1_SIG_1: [u8; 1620] = [
0, 0, 64, 31, 0, 0, 0, 7, 243, 137, 163, 140, 24, 65, 126, 88, 197, 204, 62, 74, 66, 237, 254,
110, 215, 17, 102, 40, 70, 219, 155, 241, 27, 87, 91, 102, 109, 18, 47, 186, 188, 124, 123,
172, 203, 169, 59, 246, 121, 92, 26, 174, 228, 214, 195, 54, 212, 201, 200, 49, 139, 85, 124,
165, 95, 166, 210, 125, 236, 41, 114, 252, 195, 179, 155, 6, 174, 20, 35, 81, 48, 161, 39, 23,
120, 129, 157, 93, 24, 146, 12, 81, 8, 140, 160, 54, 31, 40, 108, 211, 242, 110, 124, 18, 69,
90, 249, 244, 159, 208, 203, 115, 188, 108, 167, 225, 71, 20, 136, 28, 201, 242, 105, 134, 155,
148, 156, 241, 251, 137, 100, 22, 15, 100, 185, 120, 122, 173, 15, 243, 54, 77, 9, 26, 36, 76,
234, 84, 0, 84, 167, 165, 71, 244, 205, 208, 236, 15, 100, 177, 196, 190, 108, 221, 20, 159,
199, 119, 73, 201, 204, 82, 44, 124, 49, 232, 142, 17, 58, 85, 185, 137, 89, 241, 251, 85, 186,
173, 119, 33, 163, 55, 11, 241, 42, 77, 94, 84, 217, 253, 98, 170, 188, 205, 57, 249, 137, 98,
163, 71, 121, 115, 22, 163, 226, 222, 199, 33, 21, 77, 57, 151, 92, 196, 154, 181, 189, 163,
118, 186, 148, 201, 108, 68, 217, 149, 97, 22, 95, 61, 246, 63, 192, 109, 203, 124, 81, 38, 27,
15, 222, 12, 144, 240, 226, 82, 234, 54, 119, 254, 191, 28, 252, 236, 205, 205, 249, 228, 77,
101, 252, 184, 75, 47, 70, 125, 185, 102, 180, 143, 60, 168, 120, 17, 160, 191, 150, 120, 29,
226, 135, 42, 184, 90, 0, 49, 35, 217, 91, 12, 75, 110, 40, 224, 249, 92, 169, 11, 208, 231,
88, 114, 231, 249, 78, 41, 85, 95, 223, 52, 108, 200, 230, 6, 154, 195, 197, 209, 171, 24, 27,
12, 0, 237, 126, 132, 97, 182, 255, 30, 45, 72, 3, 162, 114, 5, 139, 127, 8, 66, 210, 29, 116,
174, 248, 194, 91, 173, 210, 242, 175, 175, 60, 228, 178, 178, 64, 141, 127, 149, 83, 163, 27,
151, 51, 168, 248, 158, 19, 225, 72, 164, 144, 194, 137, 208, 65, 2, 220, 133, 112, 150, 245,
246, 202, 11, 222, 30, 80, 158, 54, 150, 240, 39, 203, 169, 141, 13, 15, 128, 247, 224, 77,
137, 189, 236, 7, 91, 23, 179, 73, 93, 46, 249, 101, 1, 49, 169, 240, 119, 139, 222, 232, 105,
218, 116, 27, 137, 147, 202, 196, 98, 243, 218, 196, 61, 191, 12, 232, 107, 54, 158, 90, 58,
200, 218, 131, 114, 120, 245, 218, 177, 69, 49, 45, 218, 20, 179, 93, 248, 227, 224, 144, 229,
235, 192, 79, 96, 129, 121, 45, 65, 143, 181, 121, 24, 73, 252, 90, 239, 154, 46, 99, 217, 153,
86, 147, 208, 176, 246, 146, 135, 252, 105, 186, 163, 93, 150, 107, 143, 3, 74, 3, 21, 135,
220, 127, 201, 133, 37, 192, 242, 179, 33, 240, 90, 188, 38, 210, 227, 132, 53, 61, 105, 110,
76, 118, 60, 224, 83, 185, 94, 21, 186, 101, 212, 6, 196, 8, 235, 155, 179, 209, 38, 95, 151,
163, 48, 15, 139, 164, 128, 225, 201, 46, 58, 228, 74, 176, 100, 101, 6, 245, 202, 88, 210,
148, 95, 36, 230, 2, 227, 167, 161, 17, 13, 29, 202, 80, 245, 126, 211, 86, 240, 165, 147, 36,
62, 39, 131, 112, 1, 51, 95, 197, 118, 157, 200, 117, 110, 254, 244, 53, 161, 213, 62, 232, 17,
91, 218, 255, 171, 190, 191, 102, 127, 73, 158, 74, 18, 57, 120, 130, 139, 218, 9, 252, 65,
189, 207, 109, 222, 231, 155, 84, 101, 102, 90, 70, 121, 29, 6, 183, 55, 198, 36, 93, 44, 174,
184, 45, 162, 141, 130, 224, 173, 66, 252, 191, 80, 11, 137, 222, 119, 98, 126, 182, 186, 210,
52, 75, 232, 145, 52, 233, 92, 114, 137, 75, 48, 115, 143, 3, 248, 176, 227, 176, 44, 137, 79,
129, 144, 82, 13, 52, 201, 231, 11, 67, 87, 111, 245, 44, 209, 224, 201, 202, 98, 33, 45, 106,
156, 183, 25, 79, 178, 212, 5, 112, 163, 58, 169, 240, 69, 126, 170, 170, 182, 153, 10, 108,
149, 224, 98, 83, 82, 233, 254, 195, 216, 89, 80, 97, 36, 79, 244, 228, 120, 126, 122, 155, 64,
134, 217, 12, 3, 25, 159, 253, 37, 112, 41, 255, 62, 237, 164, 106, 71, 91, 61, 212, 143, 199,
58, 52, 98, 167, 32, 44, 225, 102, 5, 69, 249, 172, 204, 138, 77, 11, 147, 9, 245, 48, 12, 185,
151, 198, 28, 161, 71, 53, 59, 247, 208, 11, 130, 37, 73, 241, 190, 81, 115, 236, 120, 248,
141, 245, 231, 199, 196, 176, 64, 116, 238, 55, 195, 67, 200, 96, 10, 132, 34, 72, 114, 225,
127, 57, 32, 125, 190, 42, 49, 2, 38, 235, 36, 177, 236, 219, 188, 154, 82, 174, 191, 229, 155,
105, 122, 159, 109, 233, 243, 142, 182, 226, 148, 67, 156, 232, 179, 70, 174, 114, 162, 143,
182, 11, 135, 211, 27, 176, 176, 15, 69, 222, 147, 250, 155, 134, 234, 40, 38, 159, 175, 62,
43, 207, 3, 186, 104, 189, 13, 143, 163, 105, 229, 185, 248, 93, 55, 118, 40, 0, 86, 217, 155,
226, 179, 245, 163, 21, 199, 150, 2, 234, 45, 253, 200, 172, 212, 236, 49, 50, 18, 121, 165,
210, 114, 202, 224, 84, 104, 171, 179, 245, 134, 197, 140, 138, 167, 145, 207, 226, 1, 160, 94,
206, 201, 102, 35, 60, 223, 0, 9, 82, 238, 145, 40, 253, 249, 61, 72, 113, 72, 147, 49, 89,
150, 121, 176, 148, 120, 59, 227, 189, 232, 26, 83, 98, 86, 59, 52, 121, 162, 9, 210, 28, 199,
247, 165, 195, 58, 122, 121, 24, 169, 1, 91, 222, 48, 48, 102, 147, 127, 255, 199, 137, 203,
246, 157, 99, 43, 89, 246, 27, 106, 146, 20, 25, 71, 206, 10, 141, 45, 158, 186, 219, 187, 87,
210, 253, 204, 72, 47, 164, 221, 174, 161, 224, 204, 184, 119, 138, 10, 162, 151, 63, 112, 181,
162, 89, 169, 224, 45, 69, 146, 19, 189, 35, 182, 193, 179, 99, 104, 190, 83, 114, 203, 204,
90, 127, 161, 189, 147, 47, 27, 81, 12, 27, 218, 62, 224, 123, 80, 131, 140, 207, 7, 62, 107,
99, 85, 161, 95, 67, 65, 235, 168, 183, 228, 168, 225, 62, 254, 69, 39, 233, 145, 140, 69, 51,
174, 188, 15, 218, 52, 175, 238, 146, 172, 192, 95, 89, 48, 39, 6, 65, 59, 176, 214, 203, 148,
10, 34, 90, 158, 88, 133, 4, 147, 198, 138, 151, 237, 121, 252, 173, 231, 195, 174, 66, 74, 88,
228, 233, 107, 27, 164, 113, 13, 11, 70, 28, 145, 141, 124, 189, 130, 203, 35, 14, 156, 14, 32,
230, 143, 62, 230, 132, 138, 193, 75, 12, 144, 224, 140, 36, 7, 69, 89, 202, 24, 232, 123, 241,
48, 71, 64, 202, 85, 208, 86, 175, 94, 214, 183, 250, 30, 140, 216, 81, 31, 110, 87, 154, 42,
200, 75, 135, 63, 222, 237, 19, 65, 110, 83, 34, 76, 153, 90, 53, 7, 133, 220, 206, 82, 0, 0,
0, 12, 234, 34, 75, 133, 111, 32, 223, 57, 192, 92, 198, 165, 13, 75, 141, 160, 198, 199, 231,
248, 87, 121, 95, 129, 13, 181, 104, 254, 55, 4, 28, 76, 29, 128, 85, 109, 34, 136, 26, 183,
180, 77, 133, 50, 112, 173, 168, 125, 70, 210, 222, 135, 49, 52, 187, 135, 36, 46, 63, 90, 11,
174, 116, 189, 218, 235, 248, 4, 102, 184, 232, 46, 55, 196, 92, 165, 22, 241, 93, 69, 123, 52,
38, 226, 49, 215, 177, 137, 63, 44, 221, 20, 37, 61, 169, 58, 27, 55, 233, 162, 70, 33, 29,
128, 190, 131, 175, 165, 184, 148, 188, 36, 201, 164, 227, 0, 169, 33, 209, 18, 69, 176, 152,
175, 94, 155, 115, 166, 179, 174, 95, 243, 205, 203, 26, 38, 8, 46, 47, 67, 134, 102, 16, 183,
86, 157, 253, 9, 47, 23, 122, 158, 212, 32, 147, 186, 66, 95, 252, 58, 251, 42, 126, 144, 51,
237, 68, 225, 244, 139, 92, 174, 206, 42, 157, 166, 76, 16, 215, 209, 154, 180, 176, 178, 127,
193, 182, 143, 123, 222, 149, 82, 30, 55, 22, 168, 253, 205, 72, 125, 72, 9, 21, 20, 187, 28,
198, 84, 78, 196, 135, 75, 14, 138, 119, 215, 128, 223, 31, 183, 47, 133, 204, 95, 225, 75,
253, 226, 27, 152, 107, 120, 223, 137, 193, 191, 216, 47, 14, 233, 126, 234, 145, 107, 178, 29,
207, 207, 17, 195, 62, 153, 145, 61, 138, 24, 191, 138, 15, 210, 183, 89, 245, 233, 150, 112,
193, 187, 37, 5, 241, 153, 28, 135, 204, 89, 86, 241, 229, 106, 159, 17, 235, 61, 94, 103, 50,
213, 26, 90, 88, 5, 179, 59, 253, 100, 95, 243, 17, 43, 252, 163, 243, 24, 234, 104, 255, 78,
112, 98, 7, 44, 120, 26, 222, 203, 101, 150, 243, 85, 19, 66, 166, 179, 60, 101, 203, 79, 91,
30, 45, 209, 48, 22, 74, 121, 31, 181, 217, 122, 55, 102, 61, 146, 129, 231, 208, 149, 173, 19,
110, 11, 225, 243, 218, 13, 185, 244, 165, 123,
];
const MSG_1_KEY_1_SIG_2: [u8; 1620] = [
0, 0, 37, 6, 0, 0, 0, 7, 204, 243, 160, 168, 240, 81, 152, 90, 73, 218, 209, 118, 145, 251, 53,
59, 35, 211, 185, 113, 202, 249, 92, 182, 108, 228, 50, 223, 27, 211, 208, 239, 189, 74, 173,
148, 115, 70, 149, 37, 61, 76, 188, 189, 0, 217, 61, 155, 85, 137, 13, 5, 142, 220, 47, 29,
214, 169, 196, 155, 157, 245, 105, 18, 208, 47, 237, 167, 97, 87, 213, 100, 63, 99, 151, 105,
189, 142, 116, 2, 125, 148, 111, 234, 141, 95, 247, 249, 158, 182, 17, 128, 128, 224, 39, 43,
66, 246, 86, 236, 158, 45, 151, 39, 104, 197, 118, 94, 57, 11, 163, 172, 180, 128, 209, 149, 5,
63, 20, 22, 203, 73, 218, 188, 109, 227, 86, 17, 54, 145, 212, 170, 231, 95, 82, 71, 120, 222,
109, 208, 46, 192, 52, 229, 28, 123, 52, 168, 105, 43, 222, 149, 111, 40, 21, 176, 36, 90, 217,
89, 121, 222, 80, 176, 92, 79, 26, 49, 75, 213, 32, 246, 41, 171, 233, 225, 29, 48, 114, 77,
112, 125, 244, 97, 56, 222, 195, 47, 76, 113, 75, 82, 161, 136, 167, 232, 132, 66, 241, 78, 98,
252, 158, 141, 165, 222, 26, 105, 77, 70, 11, 72, 226, 50, 3, 63, 114, 242, 183, 23, 128, 51,
185, 82, 167, 28, 125, 50, 139, 238, 43, 32, 171, 177, 28, 118, 213, 167, 139, 227, 197, 156,
52, 43, 17, 34, 197, 242, 159, 104, 3, 70, 123, 108, 104, 135, 108, 16, 16, 250, 244, 89, 142,
173, 252, 112, 49, 254, 237, 227, 254, 38, 164, 18, 233, 239, 43, 241, 201, 237, 11, 219, 183,
208, 246, 101, 244, 62, 163, 0, 75, 34, 138, 211, 65, 51, 243, 22, 103, 62, 135, 41, 137, 36,
112, 50, 110, 234, 131, 224, 140, 79, 213, 51, 75, 58, 21, 254, 192, 131, 162, 152, 91, 122,
181, 241, 172, 162, 171, 184, 141, 13, 124, 142, 196, 90, 141, 13, 166, 25, 251, 249, 105, 20,
52, 188, 113, 215, 35, 68, 225, 75, 206, 57, 244, 83, 232, 233, 238, 238, 8, 70, 185, 89, 111,
247, 9, 49, 188, 169, 85, 35, 90, 231, 239, 52, 177, 191, 146, 21, 131, 243, 118, 201, 218, 42,
121, 11, 192, 77, 88, 247, 3, 16, 45, 108, 79, 230, 15, 120, 140, 50, 70, 13, 110, 119, 203,
150, 9, 182, 139, 9, 135, 228, 120, 199, 11, 147, 143, 183, 141, 246, 79, 199, 2, 249, 136,
224, 47, 230, 155, 143, 27, 166, 202, 72, 108, 157, 192, 163, 199, 24, 227, 100, 198, 105, 113,
139, 69, 118, 84, 95, 101, 36, 88, 15, 172, 136, 238, 188, 56, 156, 167, 194, 30, 189, 79, 208,
212, 41, 103, 84, 126, 131, 94, 193, 21, 162, 217, 23, 140, 216, 29, 235, 162, 54, 236, 250,
172, 104, 227, 197, 239, 126, 32, 219, 226, 52, 216, 126, 154, 44, 31, 237, 0, 80, 182, 142,
165, 16, 100, 154, 229, 187, 41, 114, 65, 243, 132, 221, 74, 137, 113, 144, 188, 143, 86, 213,
98, 192, 66, 121, 71, 78, 110, 12, 83, 6, 230, 71, 139, 43, 249, 218, 73, 231, 195, 50, 58,
108, 66, 51, 84, 106, 96, 88, 205, 106, 106, 32, 9, 180, 92, 121, 168, 175, 24, 70, 147, 253,
139, 3, 94, 196, 218, 105, 35, 5, 70, 20, 49, 242, 113, 87, 172, 70, 133, 229, 66, 163, 210,
69, 105, 44, 189, 148, 193, 77, 242, 127, 67, 59, 208, 123, 31, 118, 17, 1, 61, 207, 4, 84, 18,
229, 77, 205, 97, 200, 126, 14, 99, 26, 92, 150, 120, 145, 116, 36, 251, 118, 161, 179, 39, 44,
178, 169, 111, 138, 30, 153, 243, 255, 151, 160, 122, 163, 120, 202, 147, 100, 151, 239, 91,
200, 177, 47, 74, 188, 255, 5, 250, 69, 36, 250, 83, 249, 76, 42, 77, 223, 102, 103, 238, 196,
136, 25, 184, 150, 6, 115, 207, 162, 169, 224, 151, 11, 226, 5, 24, 161, 152, 92, 225, 252, 11,
121, 83, 233, 194, 22, 240, 133, 97, 91, 233, 13, 39, 93, 205, 202, 203, 132, 174, 1, 36, 182,
46, 219, 25, 250, 177, 208, 45, 118, 116, 60, 13, 148, 30, 88, 181, 61, 244, 224, 67, 61, 33,
119, 147, 142, 180, 83, 94, 201, 18, 187, 129, 174, 24, 21, 205, 212, 202, 172, 111, 74, 159,
7, 129, 184, 121, 191, 213, 107, 53, 146, 101, 234, 9, 120, 173, 205, 83, 107, 134, 78, 76,
151, 2, 135, 172, 175, 86, 75, 26, 65, 37, 160, 65, 222, 176, 202, 179, 176, 128, 204, 104,
145, 68, 248, 170, 87, 252, 195, 72, 54, 25, 254, 253, 97, 19, 16, 104, 24, 226, 152, 179, 155,
60, 12, 131, 68, 135, 10, 93, 235, 214, 185, 223, 67, 140, 50, 123, 77, 174, 227, 61, 185, 242,
53, 149, 185, 126, 56, 120, 11, 169, 194, 52, 133, 238, 76, 51, 29, 141, 78, 215, 62, 198, 32,
28, 124, 190, 16, 136, 240, 39, 112, 151, 74, 66, 205, 161, 62, 113, 133, 250, 17, 52, 235,
185, 74, 71, 240, 198, 164, 95, 96, 159, 5, 49, 21, 140, 85, 230, 243, 242, 220, 86, 139, 86,
207, 13, 57, 169, 133, 80, 84, 56, 242, 140, 132, 188, 248, 138, 237, 230, 51, 146, 87, 136,
180, 126, 187, 8, 19, 205, 233, 128, 219, 208, 147, 243, 255, 181, 8, 44, 154, 251, 174, 181,
234, 186, 120, 233, 60, 152, 132, 115, 89, 13, 237, 169, 48, 48, 117, 244, 70, 5, 36, 249, 121,
42, 158, 246, 65, 21, 232, 134, 53, 196, 169, 105, 51, 244, 56, 64, 16, 190, 74, 88, 77, 128,
62, 237, 167, 183, 77, 76, 106, 77, 80, 172, 109, 207, 61, 90, 90, 18, 22, 172, 97, 237, 64,
220, 187, 92, 110, 123, 48, 253, 182, 153, 80, 4, 66, 28, 154, 235, 22, 30, 129, 210, 38, 89,
30, 188, 65, 207, 100, 128, 173, 102, 45, 183, 19, 34, 112, 180, 3, 157, 232, 92, 111, 223, 79,
183, 197, 92, 152, 169, 247, 206, 127, 105, 101, 170, 96, 129, 110, 131, 162, 12, 40, 231, 64,
71, 181, 77, 3, 240, 61, 185, 60, 251, 32, 102, 126, 34, 158, 65, 110, 124, 245, 49, 167, 4,
47, 215, 235, 34, 187, 102, 36, 105, 228, 63, 93, 246, 252, 30, 14, 118, 34, 153, 99, 146, 67,
182, 30, 84, 153, 131, 139, 196, 232, 253, 151, 2, 36, 224, 187, 18, 221, 127, 225, 246, 220,
169, 170, 11, 60, 206, 156, 195, 218, 52, 231, 14, 114, 53, 230, 145, 202, 223, 52, 30, 202,
136, 235, 165, 148, 147, 217, 25, 25, 15, 43, 209, 77, 228, 220, 231, 186, 133, 247, 25, 159,
17, 138, 71, 164, 51, 252, 253, 102, 101, 128, 27, 230, 41, 136, 88, 200, 59, 89, 69, 232, 95,
38, 5, 199, 217, 253, 68, 37, 154, 16, 219, 183, 142, 134, 130, 90, 186, 103, 152, 35, 122,
181, 4, 104, 48, 239, 193, 210, 179, 74, 174, 42, 81, 83, 210, 56, 246, 255, 238, 205, 141,
112, 117, 11, 127, 88, 16, 249, 46, 102, 123, 236, 50, 236, 28, 255, 243, 170, 252, 68, 0, 0,
0, 12, 228, 249, 110, 226, 189, 110, 35, 51, 1, 249, 77, 57, 194, 179, 37, 78, 197, 152, 251,
21, 14, 205, 170, 90, 58, 247, 230, 171, 134, 149, 110, 227, 16, 68, 110, 104, 198, 138, 84,
41, 80, 217, 42, 215, 253, 244, 167, 133, 230, 2, 29, 42, 190, 62, 216, 45, 5, 88, 23, 181, 36,
120, 112, 5, 74, 48, 70, 15, 14, 116, 130, 98, 84, 169, 8, 155, 204, 199, 106, 204, 14, 19, 62,
229, 231, 162, 79, 197, 195, 247, 41, 133, 174, 110, 140, 243, 25, 228, 10, 206, 55, 136, 60,
109, 206, 177, 136, 96, 124, 61, 154, 148, 2, 254, 24, 185, 85, 39, 153, 117, 172, 192, 12, 97,
182, 46, 10, 98, 110, 54, 134, 46, 39, 157, 179, 74, 199, 121, 249, 224, 171, 136, 64, 90, 92,
75, 108, 16, 248, 0, 42, 3, 59, 153, 7, 5, 220, 221, 246, 52, 238, 105, 1, 37, 96, 242, 67, 1,
177, 167, 184, 140, 180, 249, 0, 246, 52, 86, 47, 80, 150, 32, 82, 16, 187, 241, 242, 72, 32,
200, 38, 83, 59, 98, 10, 88, 236, 67, 184, 242, 225, 107, 99, 161, 243, 212, 75, 218, 28, 203,
33, 185, 103, 71, 1, 11, 211, 231, 5, 108, 122, 180, 58, 162, 43, 201, 85, 164, 219, 10, 149,
95, 250, 152, 91, 206, 215, 36, 174, 78, 2, 98, 24, 143, 71, 178, 1, 10, 83, 149, 88, 132, 7,
11, 161, 94, 89, 178, 219, 41, 211, 59, 105, 160, 79, 77, 41, 108, 9, 68, 6, 75, 213, 166, 50,
157, 51, 95, 167, 45, 72, 105, 191, 163, 21, 221, 234, 194, 59, 38, 72, 229, 233, 86, 34, 100,
200, 97, 169, 213, 98, 67, 211, 200, 52, 61, 92, 172, 233, 92, 136, 46, 166, 113, 214, 248, 67,
24, 234, 11, 180, 113, 171, 48, 121, 162, 73, 161, 16, 231, 213, 8, 43, 94, 38, 30, 98, 113,
57, 190, 78, 203, 96, 136, 149, 89, 75, 161, 191, 45, 48, 146, 10, 250, 179, 174, 120, 181,
152, 193,
];
const MSG_1_PUB_KEY_2: [u8; 48] = [
0, 0, 0, 12, 0, 0, 0, 7, 133, 126, 159, 249, 229, 185, 2, 229, 193, 208, 166, 14, 150, 165, 23,
92, 243, 217, 164, 27, 214, 246, 15, 224, 110, 33, 247, 97, 140, 222, 160, 30, 248, 76, 227,
60, 252, 179, 54, 116,
];
const MSG_1_KEY_2_SIG_1: [u8; 1620] = [
0, 0, 31, 97, 0, 0, 0, 7, 49, 178, 22, 92, 253, 49, 57, 137, 42, 137, 25, 15, 250, 170, 3, 233,
219, 225, 127, 24, 106, 241, 4, 25, 147, 82, 49, 97, 144, 88, 75, 30, 250, 107, 60, 13, 161,
92, 223, 244, 37, 220, 11, 72, 47, 61, 111, 81, 5, 202, 223, 87, 24, 13, 82, 188, 111, 140, 53,
140, 63, 74, 12, 214, 216, 162, 75, 29, 190, 32, 148, 40, 167, 142, 236, 23, 168, 218, 19, 6,
126, 63, 21, 65, 109, 187, 34, 181, 251, 6, 35, 53, 245, 59, 87, 95, 91, 1, 64, 58, 126, 69,
202, 163, 171, 8, 217, 135, 218, 231, 48, 250, 21, 45, 242, 180, 83, 240, 99, 201, 155, 68,
227, 68, 103, 111, 98, 216, 59, 250, 198, 8, 88, 111, 139, 29, 101, 220, 84, 165, 129, 195,
125, 135, 67, 124, 169, 4, 132, 210, 38, 197, 106, 54, 164, 70, 152, 203, 15, 205, 195, 142,
122, 235, 211, 5, 129, 221, 80, 156, 49, 102, 181, 229, 209, 146, 228, 228, 201, 72, 240, 50,
124, 195, 187, 13, 101, 78, 69, 245, 37, 131, 250, 83, 36, 243, 3, 110, 197, 181, 217, 41, 227,
246, 18, 172, 171, 35, 130, 154, 158, 153, 157, 212, 207, 109, 245, 181, 85, 149, 72, 246, 177,
45, 140, 179, 154, 174, 120, 239, 105, 71, 154, 37, 204, 157, 6, 195, 70, 60, 5, 81, 231, 25,
12, 18, 124, 91, 111, 191, 110, 29, 58, 54, 200, 109, 182, 55, 154, 91, 15, 58, 255, 234, 220,
107, 128, 102, 148, 205, 226, 91, 202, 220, 174, 67, 147, 102, 62, 112, 35, 215, 12, 172, 85,
159, 16, 81, 183, 194, 193, 238, 236, 52, 44, 242, 59, 165, 49, 255, 191, 175, 206, 73, 246, 6,
9, 170, 22, 153, 222, 154, 35, 78, 239, 233, 56, 202, 253, 223, 33, 177, 237, 161, 136, 135,
32, 211, 174, 199, 94, 17, 30, 7, 25, 54, 227, 50, 198, 12, 128, 245, 148, 174, 69, 202, 25,
134, 242, 94, 227, 81, 23, 80, 66, 175, 224, 69, 104, 0, 35, 127, 85, 9, 31, 243, 124, 140,
199, 86, 242, 95, 88, 166, 98, 93, 225, 198, 209, 94, 252, 180, 14, 181, 159, 103, 85, 4, 200,
104, 147, 66, 114, 48, 147, 104, 148, 204, 219, 62, 160, 42, 3, 205, 84, 129, 220, 67, 226,
229, 232, 202, 23, 117, 215, 170, 37, 44, 34, 250, 10, 219, 22, 47, 222, 61, 1, 9, 68, 75, 15,
237, 173, 100, 98, 7, 197, 249, 36, 192, 7, 240, 190, 185, 236, 133, 174, 236, 75, 223, 13,
221, 25, 190, 253, 240, 89, 95, 240, 128, 135, 36, 110, 251, 209, 202, 101, 242, 57, 195, 185,
131, 149, 66, 48, 27, 27, 211, 12, 156, 202, 105, 248, 232, 199, 198, 175, 12, 127, 214, 78,
185, 192, 158, 118, 108, 13, 71, 240, 36, 132, 126, 208, 138, 40, 81, 58, 229, 77, 110, 76, 75,
115, 220, 154, 90, 1, 38, 84, 108, 114, 163, 179, 165, 79, 46, 204, 122, 94, 233, 231, 35, 155,
253, 208, 229, 9, 254, 92, 65, 127, 84, 18, 97, 62, 47, 22, 208, 204, 231, 113, 167, 11, 66,
97, 195, 154, 64, 84, 204, 250, 137, 216, 72, 36, 94, 238, 94, 143, 251, 60, 243, 191, 140,
218, 151, 146, 148, 4, 146, 183, 65, 244, 114, 143, 200, 60, 168, 233, 123, 105, 72, 57, 161,
149, 100, 207, 108, 35, 241, 235, 131, 245, 187, 100, 128, 115, 119, 229, 0, 38, 172, 215, 220,
114, 225, 234, 66, 54, 90, 22, 202, 103, 212, 238, 33, 143, 50, 109, 115, 147, 24, 201, 3, 136,
23, 36, 74, 250, 130, 73, 19, 122, 188, 20, 29, 127, 192, 45, 159, 41, 139, 190, 247, 186, 47,
242, 174, 113, 119, 87, 26, 19, 49, 212, 62, 6, 8, 74, 79, 45, 3, 190, 148, 222, 3, 101, 83,
197, 189, 105, 216, 48, 124, 126, 39, 22, 191, 97, 66, 158, 201, 189, 100, 193, 142, 8, 154,
226, 100, 193, 28, 219, 54, 101, 78, 19, 218, 119, 216, 214, 151, 165, 224, 167, 16, 229, 39,
75, 240, 243, 123, 234, 103, 80, 225, 123, 136, 128, 36, 222, 138, 218, 250, 146, 174, 55, 138,
119, 247, 215, 135, 232, 74, 82, 127, 82, 93, 232, 99, 193, 172, 252, 101, 84, 157, 208, 4,
123, 70, 56, 126, 170, 101, 171, 211, 141, 198, 41, 151, 89, 185, 207, 202, 212, 15, 223, 29,
189, 209, 47, 7, 64, 32, 109, 61, 5, 147, 219, 96, 40, 214, 166, 95, 202, 77, 220, 100, 38,
233, 182, 190, 114, 245, 225, 74, 49, 198, 223, 244, 100, 104, 186, 170, 252, 46, 175, 67, 131,
251, 29, 66, 74, 233, 127, 17, 90, 5, 182, 161, 211, 198, 251, 189, 60, 150, 18, 137, 127, 118,
129, 47, 166, 242, 7, 191, 138, 206, 98, 87, 48, 149, 39, 43, 150, 188, 17, 234, 220, 10, 183,
193, 251, 118, 72, 110, 163, 4, 233, 249, 173, 111, 15, 139, 161, 242, 248, 220, 233, 13, 76,
27, 27, 156, 238, 234, 66, 149, 219, 22, 75, 188, 184, 134, 55, 5, 183, 108, 100, 125, 167, 83,
142, 38, 17, 91, 128, 71, 33, 131, 205, 4, 228, 95, 246, 233, 207, 36, 34, 182, 95, 231, 26,
163, 119, 49, 168, 86, 227, 28, 235, 151, 241, 218, 251, 129, 196, 22, 13, 48, 70, 162, 217,
142, 38, 245, 144, 22, 44, 58, 153, 148, 130, 154, 196, 88, 6, 77, 94, 250, 37, 8, 248, 9, 65,
76, 235, 1, 83, 44, 38, 111, 241, 35, 7, 73, 211, 166, 231, 175, 216, 93, 131, 231, 86, 35, 73,
161, 112, 5, 63, 14, 122, 84, 22, 231, 177, 116, 195, 140, 28, 189, 45, 11, 46, 220, 243, 154,
90, 48, 88, 45, 215, 102, 22, 81, 165, 114, 109, 119, 70, 23, 141, 117, 92, 149, 65, 35, 42,
19, 199, 85, 186, 110, 223, 81, 143, 135, 226, 128, 126, 74, 78, 87, 237, 80, 70, 76, 63, 247,
150, 65, 212, 98, 170, 182, 21, 81, 123, 173, 113, 77, 213, 49, 0, 177, 147, 188, 203, 44, 251,
129, 55, 43, 237, 39, 239, 43, 86, 186, 252, 221, 246, 47, 65, 155, 52, 103, 45, 27, 7, 200,
15, 34, 42, 2, 247, 228, 159, 114, 32, 57, 243, 223, 249, 124, 205, 250, 46, 244, 81, 142, 100,
36, 232, 233, 82, 218, 108, 125, 111, 134, 223, 165, 134, 215, 227, 71, 249, 234, 181, 41, 32,
64, 149, 102, 43, 52, 149, 64, 133, 227, 27, 195, 189, 72, 53, 221, 212, 187, 75, 236, 202,
230, 171, 170, 255, 191, 16, 82, 204, 197, 106, 35, 222, 95, 46, 19, 204, 199, 125, 232, 22,
114, 198, 171, 42, 152, 122, 223, 2, 7, 183, 234, 129, 174, 204, 163, 171, 74, 192, 149, 132,
154, 15, 132, 176, 180, 23, 97, 147, 158, 161, 232, 222, 146, 206, 27, 22, 39, 35, 230, 125,
205, 231, 222, 114, 1, 46, 144, 195, 52, 45, 241, 48, 104, 177, 26, 63, 43, 197, 93, 231, 13,
152, 254, 158, 176, 88, 61, 193, 42, 205, 41, 43, 239, 244, 75, 0, 0, 0, 12, 207, 102, 219,
168, 252, 158, 157, 214, 241, 218, 208, 70, 121, 76, 146, 182, 48, 54, 231, 180, 221, 210, 41,
65, 25, 224, 190, 171, 74, 117, 206, 243, 114, 35, 222, 219, 123, 115, 248, 79, 41, 191, 44,
45, 243, 63, 83, 195, 140, 206, 253, 142, 198, 30, 135, 35, 225, 57, 227, 14, 205, 74, 99, 215,
255, 154, 155, 245, 158, 150, 197, 208, 39, 14, 193, 158, 147, 100, 98, 219, 20, 140, 158, 164,
172, 38, 152, 120, 162, 10, 167, 185, 182, 164, 91, 102, 217, 90, 23, 53, 183, 43, 153, 101,
39, 250, 117, 143, 168, 112, 107, 115, 5, 0, 138, 47, 42, 231, 210, 4, 244, 185, 75, 188, 65,
147, 162, 244, 64, 56, 254, 231, 81, 154, 157, 119, 168, 229, 119, 36, 197, 223, 195, 169, 9,
68, 36, 216, 42, 251, 241, 111, 217, 186, 27, 169, 31, 2, 67, 182, 45, 178, 6, 27, 136, 42,
233, 64, 241, 189, 113, 13, 202, 225, 149, 208, 20, 160, 15, 57, 218, 199, 54, 193, 75, 106,
142, 209, 153, 127, 65, 153, 164, 78, 195, 10, 198, 67, 37, 192, 130, 90, 177, 113, 89, 70, 5,
136, 249, 236, 212, 230, 101, 210, 243, 98, 50, 173, 58, 170, 39, 59, 18, 109, 52, 163, 51,
219, 10, 116, 35, 183, 154, 237, 94, 34, 187, 216, 144, 157, 108, 231, 225, 207, 65, 205, 153,
210, 228, 177, 145, 167, 109, 172, 243, 165, 144, 140, 37, 135, 248, 87, 23, 194, 10, 89, 52,
53, 95, 218, 65, 5, 121, 60, 67, 56, 88, 194, 4, 253, 217, 80, 35, 199, 3, 241, 90, 49, 15,
224, 92, 226, 84, 21, 17, 64, 248, 93, 43, 129, 96, 67, 188, 135, 155, 119, 8, 5, 149, 177, 23,
188, 47, 39, 148, 198, 134, 98, 191, 3, 25, 31, 58, 105, 116, 71, 4, 21, 201, 196, 13, 188, 89,
213, 132, 96, 182, 240, 217, 33, 214, 168, 212, 67, 24, 106, 240, 30, 101, 151, 94, 206, 1,
140, 99, 76, 195, 103, 6, 102,
];
const MSG_1_KEY_2_SIG_2: [u8; 1620] = [
0, 0, 8, 74, 0, 0, 0, 7, 21, 85, 96, 186, 161, 84, 188, 77, 54, 213, 235, 175, 219, 135, 161,
197, 151, 161, 187, 239, 69, 66, 11, 143, 50, 121, 159, 79, 7, 64, 73, 54, 141, 79, 83, 60, 90,
200, 82, 121, 168, 111, 150, 128, 250, 252, 203, 32, 146, 123, 162, 14, 151, 2, 103, 237, 107,
219, 252, 101, 217, 63, 97, 140, 104, 84, 204, 114, 250, 52, 198, 216, 95, 43, 168, 211, 149,
133, 45, 208, 63, 138, 143, 164, 88, 137, 251, 74, 106, 218, 12, 12, 224, 20, 11, 3, 184, 206,
87, 52, 33, 200, 85, 247, 230, 118, 238, 191, 19, 2, 192, 249, 18, 64, 229, 135, 190, 51, 202,
165, 72, 99, 8, 146, 14, 101, 27, 124, 255, 181, 205, 70, 169, 62, 204, 85, 8, 77, 6, 9, 146,
26, 17, 216, 76, 82, 205, 246, 147, 73, 242, 130, 10, 7, 66, 31, 162, 188, 79, 60, 152, 89,
224, 218, 248, 174, 73, 45, 126, 85, 231, 26, 38, 210, 138, 253, 162, 27, 85, 126, 65, 46, 168,
91, 57, 162, 204, 209, 156, 251, 187, 69, 78, 234, 202, 182, 246, 124, 250, 19, 188, 233, 57,
91, 52, 205, 25, 12, 182, 90, 83, 102, 199, 122, 119, 7, 101, 174, 173, 143, 6, 251, 73, 136,
5, 29, 202, 196, 159, 194, 56, 246, 33, 101, 183, 33, 155, 51, 7, 65, 133, 5, 188, 128, 110,
194, 1, 242, 181, 203, 177, 125, 70, 196, 101, 188, 221, 171, 161, 141, 80, 20, 99, 51, 192,
77, 129, 249, 170, 27, 38, 247, 121, 16, 231, 41, 93, 119, 180, 236, 250, 21, 249, 28, 77, 48,
170, 220, 119, 66, 53, 54, 20, 21, 205, 133, 131, 203, 20, 15, 221, 6, 255, 116, 14, 18, 187,
81, 102, 248, 10, 209, 20, 230, 246, 234, 86, 167, 227, 222, 160, 88, 48, 34, 77, 2, 92, 129,
216, 54, 244, 130, 207, 98, 5, 89, 126, 147, 137, 80, 136, 196, 29, 180, 151, 228, 61, 166,
168, 84, 133, 232, 0, 107, 227, 149, 146, 206, 35, 162, 77, 134, 85, 37, 238, 155, 37, 223,
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_firmware_verify.rs | runtime/tests/runtime_integration_tests/test_firmware_verify.rs | // Licensed under the Apache-2.0 license
use crate::common::{start_rt_test_pqc_model, RuntimeTestArgs};
use caliptra_api::mailbox::{FirmwareVerifyResp, FirmwareVerifyResult};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::CommandId;
use caliptra_hw_model::{HwModel, ModelError};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_kat::CaliptraError;
use zerocopy::FromBytes;
#[test]
fn test_firmware_verify_success() {
let (mut model, image) = start_rt_test_pqc_model(
RuntimeTestArgs::default(),
FwVerificationPqcKeyType::default(),
);
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let resp = model
.mailbox_execute(u32::from(CommandId::FIRMWARE_VERIFY), image.as_slice())
.unwrap()
.expect("Failed to verify valid caliptra image");
let firmware_verify_resp = FirmwareVerifyResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
firmware_verify_resp.verify_result,
FirmwareVerifyResult::Success as u32
);
}
#[test]
fn test_firmware_verify_invalid_image() {
let (mut model, _) = start_rt_test_pqc_model(
RuntimeTestArgs::default(),
FwVerificationPqcKeyType::default(),
);
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let invalid_image = vec![0u8; 1024]; // An obviously invalid image
let resp = model.mailbox_execute(
u32::from(CommandId::FIRMWARE_VERIFY),
invalid_image.as_slice(),
);
if cfg!(feature = "fpga_subsystem") {
// Since the mbox is smaller a different error gets reported
assert_eq!(
resp.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::IMAGE_VERIFIER_ERR_MANIFEST_SIZE_MISMATCH.into()
)
);
} else {
let resp = resp
.unwrap()
.expect("Expected a response for invalid image");
let firmware_verify_resp = FirmwareVerifyResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
firmware_verify_resp.verify_result,
FirmwareVerifyResult::Failure as u32
);
}
let invalid_image = vec![0u8; 32 * 1024]; // An obviously invalid image
let resp = model
.mailbox_execute(
u32::from(CommandId::FIRMWARE_VERIFY),
invalid_image.as_slice(),
)
.unwrap()
.expect("Expected a response for invalid image");
let firmware_verify_resp = FirmwareVerifyResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
firmware_verify_resp.verify_result,
FirmwareVerifyResult::Failure as u32
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_fips.rs | runtime/tests/runtime_integration_tests/test_fips.rs | // Licensed under the Apache-2.0 license.
use crate::common::{assert_error, run_rt_test, RuntimeTestArgs};
use caliptra_api::SocManager;
use caliptra_builder::{version, ImageOptions};
use caliptra_common::mailbox_api::{
CommandId, FipsVersionResp, MailboxReqHeader, MailboxRespHeader,
};
use caliptra_hw_model::HwModel;
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::FipsVersionCmd;
use zerocopy::{FromBytes, IntoBytes};
const HW_REV_ID: u32 = 0x112;
#[test]
fn test_fips_version() {
let args = RuntimeTestArgs {
test_image_options: Some(ImageOptions {
fmc_version: version::get_fmc_version(),
app_version: version::get_runtime_version(),
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
}),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
// VERSION
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::VERSION), &[]),
};
let fips_version_resp = model
.mailbox_execute(u32::from(CommandId::VERSION), payload.as_bytes())
.unwrap()
.unwrap();
// Check command size
let fips_version_bytes: &[u8] = fips_version_resp.as_bytes();
// Check values against expected.
let fips_version = FipsVersionResp::read_from_bytes(fips_version_bytes).unwrap();
assert!(caliptra_common::checksum::verify_checksum(
fips_version.hdr.chksum,
0x0,
&fips_version.as_bytes()[core::mem::size_of_val(&fips_version.hdr.chksum)..],
));
assert_eq!(
fips_version.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
assert_eq!(fips_version.mode, FipsVersionCmd::MODE);
// fw_rev[0] is FMC version at 31:16 and ROM version at 15:0
// Ignore ROM version since this test is for runtime
let fw_version_0_expected = (version::get_fmc_version() as u32) << 16;
assert_eq!(
[
fips_version.fips_rev[0],
fips_version.fips_rev[1] & 0xFFFF0000, // Mask out the ROM version
fips_version.fips_rev[2],
],
[
HW_REV_ID,
fw_version_0_expected,
version::get_runtime_version()
]
);
let name = &fips_version.name[..];
assert_eq!(name, FipsVersionCmd::NAME.as_bytes());
}
#[test]
fn test_fips_shutdown() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
// SHUTDOWN
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::SHUTDOWN), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::SHUTDOWN), payload.as_bytes())
.unwrap()
.unwrap();
let resp = MailboxRespHeader::read_from_bytes(resp.as_slice()).unwrap();
// Verify checksum and FIPS status
assert!(caliptra_common::checksum::verify_checksum(
resp.chksum,
0x0,
&resp.as_bytes()[core::mem::size_of_val(&resp.chksum)..],
));
assert_eq!(resp.fips_status, MailboxRespHeader::FIPS_STATUS_APPROVED);
// Check we are rejecting additional commands with the shutdown error code.
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::VERSION), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::VERSION), payload.as_bytes())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_SHUTDOWN,
resp,
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_cap_warmreset.rs | runtime/tests/runtime_integration_tests/test_cap_warmreset.rs | // Licensed under the Apache-2.0 license
use crate::common::{run_rt_test_pqc, RuntimeTestArgs};
use caliptra_common::{
capabilities::Capabilities,
checksum::{calc_checksum, verify_checksum},
mailbox_api::{CapabilitiesResp, CommandId, MailboxReqHeader, MailboxRespHeader},
};
use caliptra_hw_model::{DefaultHwModel, HwModel};
use zerocopy::{FromBytes, IntoBytes};
fn get_capabilities(model: &mut DefaultHwModel) -> (CapabilitiesResp, Vec<u8>) {
let payload = MailboxReqHeader {
chksum: calc_checksum(u32::from(CommandId::CAPABILITIES), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::CAPABILITIES), payload.as_bytes())
.expect("mailbox_execute failed")
.expect("CAPABILITIES returned no data");
assert!(!resp.is_empty(), "CAPABILITIES returned empty payload");
let capabilities_resp =
CapabilitiesResp::read_from_bytes(resp.as_slice()).expect("parse CapabilitiesResp failed");
// Verify response checksum (exclude the checksum field itself).
assert!(
verify_checksum(
capabilities_resp.hdr.chksum,
0x0,
&capabilities_resp.as_bytes()[core::mem::size_of_val(&capabilities_resp.hdr.chksum)..],
),
"CAPABILITIES response checksum invalid"
);
assert_eq!(
capabilities_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED,
"CAPABILITIES FIPS not APPROVED"
);
(capabilities_resp, resp)
}
#[test]
fn test_capabilities_after_warm_reset() {
let mut model = run_rt_test_pqc(RuntimeTestArgs::test_productions_args(), Default::default());
// --- Before warm reset ---
let (cap_resp_before, raw_resp_before) = get_capabilities(&mut model);
let capabilities_before =
Capabilities::try_from(&cap_resp_before.capabilities[..]).expect("decode caps");
assert!(capabilities_before.contains(Capabilities::RT_BASE));
// --- Warm reset ---
model.warm_reset_flow().unwrap();
// --- After warm reset ---
let (cap_resp_after, raw_resp_after) = get_capabilities(&mut model);
let capabilities_after =
Capabilities::try_from(&cap_resp_after.capabilities[..]).expect("decode caps");
assert!(capabilities_after.contains(Capabilities::RT_BASE));
assert_eq!(
raw_resp_before, raw_resp_after,
"Raw CAPABILITIES changed across warm reset"
);
assert_eq!(
cap_resp_before.as_bytes(),
cap_resp_after.as_bytes(),
"Typed CAPABILITIES bytes changed across warm reset"
);
assert_eq!(
capabilities_before.to_bytes(),
capabilities_after.to_bytes(),
"Capability bitflags changed across warm reset"
); //
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_pauser_privilege_levels.rs | runtime/tests/runtime_integration_tests/test_pauser_privilege_levels.rs | // Licensed under the Apache-2.0 license
use crate::common::PQC_KEY_TYPE;
use caliptra_api::{
mailbox::{RevokeExportedCdiHandleReq, SignWithExportedEcdsaReq},
SocManager,
};
use caliptra_builder::{
build_firmware_elf,
firmware::{APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::mailbox_api::{
CertifyKeyExtendedFlags, CertifyKeyExtendedReq, CommandId, MailboxReq, MailboxReqHeader,
PopulateIdevEcc384CertReq, StashMeasurementReq,
};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{BootParams, Fuses, HwModel, InitParams, SecurityState};
use caliptra_image_crypto::OsslCrypto as Crypto;
use caliptra_image_elf::ElfExecutable;
use caliptra_image_gen::{ImageGenerator, ImageGeneratorConfig};
use caliptra_image_types::{FwVerificationPqcKeyType, ImageSignData};
use caliptra_runtime::{
RtBootStatus, PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD,
PL1_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD,
};
use dpe::{
commands::{
CertifyKeyCmd, CertifyKeyFlags, Command, DeriveContextCmd, DeriveContextFlags, InitCtxCmd,
RotateCtxCmd, RotateCtxFlags,
},
context::ContextHandle,
response::Response,
DPE_PROFILE,
};
use zerocopy::IntoBytes;
use crate::common::{
assert_error, execute_dpe_cmd, run_rt_test, run_rt_test_pqc, DpeResult, RuntimeTestArgs,
TEST_LABEL,
};
const DATA: [u8; DPE_PROFILE.hash_size()] = [0u8; 48];
#[test]
fn test_pl0_derive_context_dpe_context_thresholds() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// First rotate the default context so that we don't run into an error
// when trying to retain the default context in derive child.
let rotate_ctx_cmd = RotateCtxCmd {
handle: ContextHandle::default(),
flags: RotateCtxFlags::empty(),
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::RotateCtx(&rotate_ctx_cmd),
DpeResult::Success,
);
let Some(Response::RotateCtx(rotate_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
let mut handle = rotate_ctx_resp.handle;
// Call DeriveContext with PL0 enough times to breach the threshold on the last iteration.
// 2 PL0 contexts are used by default by Caliptra. When we initialize DPE, we measure mailbox valid pausers in pl0_pauser's locality.
// The RT Journey measurement also is counted against PL0's limit. Thus, we can call derive child
// from PL0 exactly 14 times, and the last iteration of this loop, is expected to throw a threshold reached error.
let num_iterations = PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 1;
for i in 0..num_iterations {
let derive_context_cmd = DeriveContextCmd {
handle,
data: DATA,
flags: DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// If we are on the last call to DeriveContext, expect that we get a RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED error.
if i == num_iterations - 1 {
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::MboxCmdFailure(
caliptra_drivers::CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED,
),
);
assert!(resp.is_none());
break;
}
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(derive_context_resp)) = resp else {
panic!("Wrong response type!");
};
handle = derive_context_resp.handle;
}
}
#[test]
fn test_pl1_derive_context_dpe_context_thresholds() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// First initialize a simulation context in locality 1
// so that we get a non-default handle which we can use
// when calling DeriveContext with the RETAIN_PARENT_CONTEXT flag
let init_ctx_cmd = InitCtxCmd::new_simulation();
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::Success,
);
let Some(Response::InitCtx(init_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
let mut handle = init_ctx_resp.handle;
// Call DeriveContext with PL1 enough times to breach the threshold on the last iteration.
// Note that this loop runs exactly PL1_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD times.
// Then, we initialize a simulation context in locality 1. Thus, we can call derive child
// from PL1 exactly 16 - 1 = 15 times, and the last iteration of this loop, is expected to throw a threshold breached error.
let num_iterations = PL1_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD;
for i in 0..num_iterations {
let derive_context_cmd = DeriveContextCmd {
handle,
data: DATA,
flags: DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// If we are on the last call to DeriveContext, expect that we get a RUNTIME_PL1_USED_DPE_CONTEXT_THRESHOLD_REACHED error.
if i == num_iterations - 1 {
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::MboxCmdFailure(
caliptra_drivers::CaliptraError::RUNTIME_PL1_USED_DPE_CONTEXT_THRESHOLD_REACHED,
),
);
assert!(resp.is_none());
break;
}
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContext(derive_context_resp)) = resp else {
panic!("Wrong response type!");
};
handle = derive_context_resp.handle;
}
}
}
#[test]
fn test_pl0_init_ctx_dpe_context_thresholds() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// 2 PL0 contexts are used by Caliptra
let num_iterations = PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 1;
for i in 0..num_iterations {
let init_ctx_cmd = InitCtxCmd::new_simulation();
// If we are on the last call to InitializeContext, expect that we get a PL0_USED_DPE_CONTEXT_THRESHOLD_EXCEEDED error.
if i == num_iterations - 1 {
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::MboxCmdFailure(
caliptra_drivers::CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED,
),
);
assert!(resp.is_none());
break;
}
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::Success,
);
let Some(Response::InitCtx(_)) = resp else {
panic!("Wrong response type!");
};
}
}
#[test]
fn test_pl1_init_ctx_dpe_context_thresholds() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let num_iterations = PL1_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD;
for i in 0..(num_iterations + 1) {
let init_ctx_cmd = InitCtxCmd::new_simulation();
// InitCtx should fail on the PL1_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD iteration
if i == num_iterations {
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::MboxCmdFailure(
caliptra_drivers::CaliptraError::RUNTIME_PL1_USED_DPE_CONTEXT_THRESHOLD_REACHED,
),
);
assert!(resp.is_none());
break;
}
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::Success,
);
let Some(Response::InitCtx(_)) = resp else {
panic!("Wrong response type!");
};
}
}
}
#[test]
fn test_change_locality() {
let args = RuntimeTestArgs {
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
model.set_axi_user(0x01);
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: DATA,
flags: DeriveContextFlags::CHANGE_LOCALITY
| DeriveContextFlags::MAKE_DEFAULT
| DeriveContextFlags::INPUT_ALLOW_X509,
tci_type: 0,
target_locality: 2,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
)
.unwrap();
model.set_axi_user(0x02);
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: DATA,
flags: DeriveContextFlags::MAKE_DEFAULT,
tci_type: 0,
target_locality: 2,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
)
.unwrap();
}
#[test]
fn test_populate_idev_cannot_be_called_from_pl1() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut pop_idev_cmd =
MailboxReq::PopulateIdevEcc384Cert(PopulateIdevEcc384CertReq::default());
pop_idev_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::POPULATE_IDEV_ECC384_CERT),
pop_idev_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
resp,
);
}
}
#[test]
fn test_stash_measurement_cannot_be_called_from_pl1() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cmd = MailboxReq::StashMeasurement(StashMeasurementReq::default());
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
resp,
);
}
}
#[test]
fn test_sign_with_exported_ecdsa_cannot_be_called_from_pl1() {
let mut image_opts = ImageOptions::default();
image_opts.vendor_config.pl0_pauser = None;
image_opts.pqc_key_type = FwVerificationPqcKeyType::LMS;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cmd = MailboxReq::SignWithExportedEcdsa(SignWithExportedEcdsaReq::default());
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::SIGN_WITH_EXPORTED_ECDSA),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
resp,
);
}
#[test]
fn test_revoke_export_cdi_handle_cannot_be_called_from_pl1() {
let mut image_opts = ImageOptions::default();
image_opts.vendor_config.pl0_pauser = None;
image_opts.pqc_key_type = FwVerificationPqcKeyType::LMS;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq::default());
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::REVOKE_EXPORTED_CDI_HANDLE),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
resp,
);
}
#[test]
fn test_export_cdi_cannot_be_called_from_pl1() {
let mut image_opts = ImageOptions::default();
image_opts.vendor_config.pl0_pauser = None;
image_opts.pqc_key_type = FwVerificationPqcKeyType::LMS;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let get_cert_chain_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&get_cert_chain_cmd),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL),
);
}
#[test]
fn test_certify_key_x509_cannot_be_called_from_pl1() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions::default();
image_opts.vendor_config.pl0_pauser = None;
image_opts.pqc_key_type = *pqc_key_type;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL),
);
assert!(resp.is_none());
}
}
#[test]
fn test_certify_key_extended_cannot_be_called_from_pl1() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut certify_key_extended_cmd = MailboxReq::CertifyKeyExtended(CertifyKeyExtendedReq {
hdr: MailboxReqHeader { chksum: 0 },
certify_key_req: [0u8; CertifyKeyExtendedReq::CERTIFY_KEY_REQ_SIZE],
flags: CertifyKeyExtendedFlags::empty(),
});
certify_key_extended_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::CERTIFY_KEY_EXTENDED),
certify_key_extended_cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
resp,
);
}
}
#[test]
fn test_derive_context_cannot_be_called_from_pl1_if_changes_locality_to_pl0() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = None;
let args = RuntimeTestArgs {
test_image_options: Some(image_opts),
..Default::default()
};
let mut model = run_rt_test_pqc(args, *pqc_key_type);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// init ctx since we have currently have no parent handle for pl1
let init_ctx_cmd = InitCtxCmd::new_simulation();
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::Success,
);
let Some(Response::InitCtx(init_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
let derive_context_cmd = DeriveContextCmd {
handle: init_ctx_resp.handle,
data: DATA,
flags: DeriveContextFlags::RETAIN_PARENT_CONTEXT | DeriveContextFlags::CHANGE_LOCALITY,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::MboxCmdFailure(
caliptra_drivers::CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL,
),
);
assert!(resp.is_none());
}
}
#[test]
fn test_stash_measurement_pl_context_thresholds() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Root node and RT journey (which is technically the Caliptra locality) count as PL0
let num_iterations = PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 2;
let mut cmd = MailboxReq::StashMeasurement(StashMeasurementReq {
hdr: MailboxReqHeader { chksum: 0 },
metadata: [0u8; 4],
measurement: [0u8; 48],
context: [0u8; 48],
svn: 0,
});
for _ in 0..num_iterations {
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
}
// Attempting one more should return a failure
let resp = model
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED,
resp,
);
}
#[test]
fn test_measurement_log_pl_context_threshold() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Upload (PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 1) measurements to measurement log
// Since 2 measurements taken by Caliptra upon startup, this will cause
// the PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD to be breached.
for idx in 0..(PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 1) as u8 {
let mut measurement = StashMeasurementReq {
measurement: [0xdeadbeef_u32; 12].as_bytes().try_into().unwrap(),
hdr: MailboxReqHeader { chksum: 0 },
metadata: [0u8; 4],
context: [0u8; 48],
svn: 0,
};
measurement.measurement[0] = idx;
measurement.context[1] = idx;
measurement.svn = idx as u32;
let mut measurement_req = MailboxReq::StashMeasurement(measurement);
measurement_req.populate_chksum().unwrap();
if idx == PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD as u8 - 2 {
model
.upload_measurement(measurement_req.as_bytes().unwrap())
.unwrap_err();
break;
}
model
.upload_measurement(measurement_req.as_bytes().unwrap())
.unwrap();
}
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED)
});
}
#[test]
fn test_pl0_unset_in_header() {
let fuses = Fuses {
fuse_pqc_key_type: FwVerificationPqcKeyType::LMS as u32,
..Default::default()
};
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let life_cycle = fuses.life_cycle;
let mut model = caliptra_hw_model::new(
InitParams {
fuses,
rom: &rom,
security_state: SecurityState::from(life_cycle as u32),
..Default::default()
},
BootParams::default(),
)
.unwrap();
let mut opts = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
opts.vendor_config.pl0_pauser = None;
let mut image_bundle =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, opts).unwrap();
// Change PL0 to 1 so that it matches the real PL0 PAUSER but don't set the
// flag bit to make it valid. Also need to re-generate and re-sign the image.
image_bundle.manifest.header.pl0_pauser = 1;
let opts = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let ecc_index = opts.vendor_config.ecc_key_idx;
let lms_index = opts.vendor_config.pqc_key_idx;
let gen = ImageGenerator::new(Crypto::default());
let vendor_header_digest_384 = gen
.vendor_header_digest_384(&image_bundle.manifest.header)
.unwrap();
let vendor_header_digest_holder = ImageSignData {
digest_384: &vendor_header_digest_384,
mldsa_msg: None,
};
let owner_header_digest_384 = gen
.owner_header_digest_384(&image_bundle.manifest.header)
.unwrap();
let owner_header_digest_holder = ImageSignData {
digest_384: &owner_header_digest_384,
mldsa_msg: None,
};
let fmc_elf = build_firmware_elf(&FMC_WITH_UART).unwrap();
let app_elf = build_firmware_elf(&APP_WITH_UART).unwrap();
let preamble = gen
.gen_preamble(
&ImageGeneratorConfig {
fmc: ElfExecutable::new(
&fmc_elf,
opts.fmc_version as u32,
*b"~~~~~NO_GIT_REVISION",
)
.unwrap(),
runtime: ElfExecutable::new(&app_elf, opts.app_version, *b"~~~~~NO_GIT_REVISION")
.unwrap(),
fw_svn: opts.fw_svn,
vendor_config: opts.vendor_config,
owner_config: opts.owner_config,
pqc_key_type: FwVerificationPqcKeyType::LMS,
},
ecc_index,
lms_index,
&vendor_header_digest_holder,
&owner_header_digest_holder,
)
.unwrap();
image_bundle.manifest.preamble = preamble;
crate::common::test_upload_firmware(
&mut model,
&image_bundle.to_bytes().unwrap(),
FwVerificationPqcKeyType::LMS,
);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// If PL0 PAUSER is unset, make sure PL0-only operation fails
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL),
);
assert!(resp.is_none());
}
#[test]
fn test_user_not_pl0() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let mut opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
let fuses = Fuses {
fuse_pqc_key_type: *pqc_key_type as u32,
..Default::default()
};
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let life_cycle = fuses.life_cycle;
let mut model = caliptra_hw_model::new(
InitParams {
fuses,
rom: &rom,
security_state: SecurityState::from(life_cycle as u32),
..Default::default()
},
BootParams::default(),
)
.unwrap();
opts.vendor_config.pl0_pauser = Some(0); // Caller PAUSER is always 1 for current models
let image_bundle =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, opts).unwrap();
crate::common::test_upload_firmware(
&mut model,
&image_bundle.to_bytes().unwrap(),
*pqc_key_type,
);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// If PAUSER is not PL0, make sure PL0-only operation fails
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL),
);
assert!(resp.is_none());
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_panic_missing.rs | runtime/tests/runtime_integration_tests/test_panic_missing.rs | // Licensed under the Apache-2.0 license
use caliptra_builder::firmware::APP_WITH_UART;
#[test]
fn test_panic_missing() {
let rt_elf = caliptra_builder::build_firmware_elf(&APP_WITH_UART).unwrap();
let symbols = caliptra_builder::elf_symbols(&rt_elf).unwrap();
if symbols.iter().any(|s| s.name.contains("panic_is_possible")) {
panic!(
"The caliptra RT contains the panic_is_possible symbol, which is not allowed. \
Please remove any code that might panic."
)
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_pcr.rs | runtime/tests/runtime_integration_tests/test_pcr.rs | // Licensed under the Apache-2.0 license
use crate::common::{
get_ecc_fmc_alias_cert, get_mldsa_fmc_alias_cert, run_rt_test, RuntimeTestArgs,
};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
CommandId, ExtendPcrReq, GetPcrLogResp, IncrementPcrResetCounterReq, MailboxReq,
MailboxReqHeader, QuotePcrsEcc384Req, QuotePcrsEcc384Resp, QuotePcrsMldsa87Req,
QuotePcrsMldsa87Resp,
};
use caliptra_drivers::{PcrId, PcrLogArray};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{DefaultHwModel, HwModel, ModelError};
use ml_dsa::signature::Verifier;
use ml_dsa::{MlDsa87, Signature, VerifyingKey};
use openssl::{
bn::BigNum,
ecdsa::EcdsaSig,
hash::{Hasher, MessageDigest},
x509::X509,
};
use spki::DecodePublicKey;
use x509_cert::certificate::Certificate;
use x509_cert::der::{Decode, Encode};
use zerocopy::{FromBytes, IntoBytes};
#[test]
fn test_pcr_quote_ecc() {
let mut model = run_rt_test(RuntimeTestArgs::default());
const RESET_PCR: u32 = 7;
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
let mut cmd = MailboxReq::IncrementPcrResetCounter(IncrementPcrResetCounterReq {
hdr: MailboxReqHeader { chksum: 0 },
index: RESET_PCR,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::INCREMENT_PCR_RESET_COUNTER),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let mut cmd = MailboxReq::QuotePcrsEcc384(QuotePcrsEcc384Req {
hdr: MailboxReqHeader { chksum: 0 },
nonce: [0xf5; 32],
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::QUOTE_PCRS_ECC384),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let resp = QuotePcrsEcc384Resp::read_from_bytes(resp.as_slice()).unwrap();
// Compute the digest and compare to mailbox result
let mut h = Hasher::new(MessageDigest::sha512()).unwrap();
resp.pcrs.iter().for_each(|x| h.update(x).unwrap());
h.update(&resp.nonce).unwrap();
let res = h.finish().unwrap();
let digest: [u8; 64] = res.as_bytes().try_into().unwrap();
assert_eq!(resp.digest, &digest[..48]);
let pcr7_reset_counter: u32 = resp.reset_ctrs[usize::try_from(RESET_PCR).unwrap()];
// See if incrementing the reset counter worked
assert_eq!(pcr7_reset_counter, 1);
// verify signature
let big_r = BigNum::from_slice(&resp.signature_r).unwrap();
let big_s = BigNum::from_slice(&resp.signature_s).unwrap();
let sig = EcdsaSig::from_private_components(big_r, big_s).unwrap();
let fmc_resp = get_ecc_fmc_alias_cert(&mut model);
let fmc_cert: X509 = X509::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let pkey = fmc_cert.public_key().unwrap().ec_key().unwrap();
assert!(sig.verify(&resp.digest, &pkey).unwrap());
}
#[test]
fn test_pcr_quote_mldsa() {
let mut model = run_rt_test(RuntimeTestArgs::default());
const RESET_PCR: u32 = 7;
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
let mut cmd = MailboxReq::IncrementPcrResetCounter(IncrementPcrResetCounterReq {
hdr: MailboxReqHeader { chksum: 0 },
index: RESET_PCR,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::INCREMENT_PCR_RESET_COUNTER),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let mut cmd = MailboxReq::QuotePcrsMldsa87(QuotePcrsMldsa87Req {
hdr: MailboxReqHeader { chksum: 0 },
nonce: [0xf5; 32],
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::QUOTE_PCRS_MLDSA87),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let resp = QuotePcrsMldsa87Resp::read_from_bytes(resp.as_slice()).unwrap();
// Compute the digest and compare to mailbox result
let mut h = Hasher::new(MessageDigest::sha512()).unwrap();
resp.pcrs.iter().for_each(|x| h.update(x).unwrap());
h.update(&resp.nonce).unwrap();
let res = h.finish().unwrap();
let mut digest: [u8; 64] = res.as_bytes().try_into().unwrap();
// Reverse the sequence of bytes in the digest.
// This is the byte order Caliptra hardware uses for MLDSA signing the PCR digest.
digest.reverse();
assert_eq!(resp.digest, digest);
let pcr7_reset_counter: u32 = resp.reset_ctrs[usize::try_from(RESET_PCR).unwrap()];
// See if incrementing the reset counter worked
assert_eq!(pcr7_reset_counter, 1);
// verify signature
let fmc_resp = get_mldsa_fmc_alias_cert(&mut model);
let cert = Certificate::from_der(&fmc_resp.data[..fmc_resp.data_size as usize]).unwrap();
let pk_bytes = cert
.tbs_certificate
.subject_public_key_info
.to_der()
.unwrap();
let pk = VerifyingKey::<MlDsa87>::from_public_key_der(&pk_bytes).unwrap();
let signature_bytes: [u8; 4627] = resp.signature[..4627].try_into().unwrap();
let signature = Signature::<MlDsa87>::decode((&signature_bytes).into()).unwrap();
pk.verify(&resp.digest, &signature).unwrap();
}
fn generate_mailbox_extend_pcr_req(idx: u32, pcr_extension_data: [u8; 48]) -> MailboxReq {
let mut cmd = MailboxReq::ExtendPcr(ExtendPcrReq {
hdr: MailboxReqHeader { chksum: 0 },
pcr_idx: idx,
data: pcr_extension_data,
});
cmd.populate_chksum().unwrap();
cmd
}
pub fn get_model_pcrs(model: &mut DefaultHwModel) -> [[u8; 48]; 32] {
let mut cmd = MailboxReq::QuotePcrsEcc384(QuotePcrsEcc384Req {
hdr: MailboxReqHeader { chksum: 0 },
nonce: [0u8; 32],
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::QUOTE_PCRS_ECC384),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
QuotePcrsEcc384Resp::read_from_bytes(resp.as_slice())
.unwrap()
.pcrs
}
#[test]
fn test_extend_pcr_cmd_multiple_extensions() {
fn extend_pcr(current: &[u8; 48], data: &[u8; 48]) -> [u8; 48] {
let mut h = Hasher::new(MessageDigest::sha384()).unwrap();
let _ = h.update(current);
let _ = h.update(data);
let res = h.finish().unwrap();
res.as_bytes().try_into().unwrap()
}
// 0. Get fresh pcr state and verify
let mut model = run_rt_test(RuntimeTestArgs::default());
assert_eq!(get_model_pcrs(&mut model)[4], [0u8; 48]);
// 1.0 Testing for extension_data [0,...,0]
let extension_data = [0u8; 48];
let cmd = generate_mailbox_extend_pcr_req(4, extension_data);
let res = model.mailbox_execute(u32::from(CommandId::EXTEND_PCR), cmd.as_bytes().unwrap());
assert!(res.is_ok());
// 1.1 Checking for PCR values using PCR_QUOTE
let pcrs = get_model_pcrs(&mut model);
let pcr = extend_pcr(&[0; 48], &extension_data);
assert_eq!(pcrs[4], pcr);
// 1.2 Extending PCR[4] with another [0,..,0] payload
let cmd = generate_mailbox_extend_pcr_req(4, extension_data);
let res = model.mailbox_execute(u32::from(CommandId::EXTEND_PCR), cmd.as_bytes().unwrap());
assert!(res.is_ok());
// 1.3 Checking for PCR values using PCR_QUOTE
let pcr = extend_pcr(&pcr, &extension_data);
let pcrs = get_model_pcrs(&mut model);
assert_eq!(pcrs[4], pcr);
// 2.0 Testing for extension data with high entropy
let extension_data: [u8; 48] = [
225, 73, 188, 244, 110, 120, 121, 204, 185, 203, 86, 129, 104, 186, 33, 110, 125, 116, 216,
80, 244, 199, 184, 21, 127, 187, 78, 122, 18, 26, 32, 48, 171, 251, 17, 20, 67, 224, 15,
81, 144, 232, 190, 103, 213, 7, 199, 148,
];
let cmd = generate_mailbox_extend_pcr_req(4, extension_data);
let res = model.mailbox_execute(u32::from(CommandId::EXTEND_PCR), cmd.as_bytes().unwrap());
assert!(res.is_ok());
// 2.1 Checking for PCR values using PCR_QUOTE
let pcr = extend_pcr(&pcr, &extension_data);
let pcrs = get_model_pcrs(&mut model);
assert_eq!(pcrs[4], pcr);
}
#[test]
fn test_extend_pcr_cmd_invalid_pcr_index() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let extension_data: [u8; 48] = [0u8; 48];
// 3. Invalid PCR index
let cmd = generate_mailbox_extend_pcr_req(33, extension_data);
let res = model.mailbox_execute(u32::from(CommandId::EXTEND_PCR), cmd.as_bytes().unwrap());
assert_eq!(
res,
Err(ModelError::MailboxCmdFailed(u32::from(
CaliptraError::RUNTIME_PCR_INVALID_INDEX
)))
);
}
#[test]
fn test_extend_pcr_cmd_reserved_range() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let extension_data: [u8; 48] = [0u8; 48];
// 4. Ensure reserved PCR range
let reserved_pcrs = [PcrId::PcrId0, PcrId::PcrId1, PcrId::PcrId2, PcrId::PcrId3];
for test_pcr_index_reserved in reserved_pcrs {
let cmd = generate_mailbox_extend_pcr_req(test_pcr_index_reserved.into(), extension_data);
let res = model.mailbox_execute(u32::from(CommandId::EXTEND_PCR), cmd.as_bytes().unwrap());
assert_eq!(
res,
Err(ModelError::MailboxCmdFailed(u32::from(
CaliptraError::RUNTIME_PCR_RESERVED
)))
);
}
}
#[test]
fn test_get_pcr_log() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let mut cmd = MailboxReq::GetPcrLog(MailboxReqHeader::default());
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(u32::from(CommandId::GET_PCR_LOG), cmd.as_bytes().unwrap())
.unwrap()
.unwrap();
let resp = GetPcrLogResp::read_from_bytes(resp.as_slice()).unwrap();
let log = PcrLogArray::read_from_bytes(&resp.data[..resp.data_size as usize]);
assert!(log.is_ok());
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_ecdsa.rs | runtime/tests/runtime_integration_tests/test_ecdsa.rs | // Licensed under the Apache-2.0 license.
use crate::common::{assert_error, run_rt_test, RuntimeTestArgs};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
CommandId, EcdsaVerifyReq, MailboxReq, MailboxReqHeader, MailboxRespHeader,
};
use caliptra_hw_model::HwModel;
use caliptra_runtime::RtBootStatus;
use openssl::sha::sha384;
use zerocopy::{FromBytes, IntoBytes};
// This file includes some tests from Wycheproof to testing specific common
// ECDSA problems.
// In the long term, this file should just run the entire Wycheproof test
// vector file wycheproof/testvectors_v1/ecdsa_secp384r1_sha384_test.json
#[test]
fn ecdsa_cmd_run_wycheproof() {
// This test is too slow to run as part of the verilator nightly.
#![cfg_attr(all(not(feature = "slow_tests"), feature = "verilator"), ignore)]
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read()
== <RtBootStatus as Into<u32>>::into(RtBootStatus::RtReadyForCommands)
});
#[allow(dead_code)]
#[derive(Debug)]
struct WycheproofResults {
id: usize,
comment: String,
}
// Collect all the errors and print at the end
let mut wyche_fail: Vec<WycheproofResults> = Vec::new();
let mut wyche_ran: Vec<WycheproofResults> = Vec::new();
let test_set =
wycheproof::ecdsa::TestSet::load(wycheproof::ecdsa::TestName::EcdsaSecp384r1Sha384)
.unwrap();
// The mailbox has a fixed len for x and y so filter out untestable cases
let test_groups = test_set
.test_groups
.iter()
.filter(|x| x.key.affine_x.as_slice().len() <= 48)
.filter(|x| x.key.affine_y.as_slice().len() <= 48);
for test_group in test_groups {
for test in &test_group.tests {
// Since the mailbox uses R, S as input for signature use only tests with a valid signature
let Ok(signature) = openssl::ecdsa::EcdsaSig::from_der(test.sig.as_bytes()) else {
continue;
};
if signature.r().to_vec().len() > 48 || signature.s().to_vec().len() > 48 {
continue;
}
// openssl rust crates has problems parsing some DER signatures. Skip those as those can't be
// sent to the mailbox anyway.
if [
"Legacy: ASN encoding of s misses leading 0",
"length of sequence [r, s] uses long form encoding",
"length of sequence [r, s] contains a leading 0",
"appending unused 0's to sequence [r, s]",
"indefinite length",
"indefinite length with garbage",
"length of r uses long form encoding",
"length of r contains a leading 0",
"prepending 0's to r",
"length of s uses long form encoding",
"length of s contains a leading 0",
"prepending 0's to s",
]
.contains(&test.comment.as_str())
{
continue;
}
wyche_ran.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
// TODO: change this to use the SHA mailbox command when it is available
let hash = sha384(test.msg.as_slice());
let mut cmd = MailboxReq::EcdsaVerify(EcdsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key_x: test_group.key.affine_x.as_slice()[..].try_into().unwrap(),
pub_key_y: test_group.key.affine_y.as_slice()[..].try_into().unwrap(),
signature_r: signature
.r()
.to_vec_padded(48)
.unwrap()
.as_bytes()
.try_into()
.unwrap(),
signature_s: signature
.s()
.to_vec_padded(48)
.unwrap()
.as_bytes()
.try_into()
.unwrap(),
hash,
// Do tests on mailbox
});
cmd.populate_chksum().unwrap();
let resp = model.mailbox_execute(
u32::from(CommandId::ECDSA384_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
);
match test.result {
wycheproof::TestResult::Valid | wycheproof::TestResult::Acceptable => match resp {
Err(_) | Ok(None) => {
wyche_fail.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
}
Ok(Some(resp)) => {
// Verify the checksum and FIPS status
let resp_hdr = MailboxRespHeader::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// Checksum is just going to be 0 because FIPS_STATUS_APPROVED is 0
assert_eq!(resp_hdr.chksum, 0);
}
},
wycheproof::TestResult::Invalid => {
if resp.is_ok() {
wyche_fail.push(WycheproofResults {
id: test.tc_id,
comment: test.comment.to_string(),
});
}
}
}
}
}
println!("Executed wycheproof tests:\n{:#?}", wyche_ran);
if !wyche_fail.is_empty() {
panic!(
"Number of failed tests {}:\n{:#?}",
wyche_fail.len(),
wyche_fail
);
}
}
#[test]
fn test_ecdsa_verify_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Message to hash
let msg: &[u8] = &[
0x9d, 0xd7, 0x89, 0xea, 0x25, 0xc0, 0x47, 0x45, 0xd5, 0x7a, 0x38, 0x1f, 0x22, 0xde, 0x01,
0xfb, 0x0a, 0xbd, 0x3c, 0x72, 0xdb, 0xde, 0xfd, 0x44, 0xe4, 0x32, 0x13, 0xc1, 0x89, 0x58,
0x3e, 0xef, 0x85, 0xba, 0x66, 0x20, 0x44, 0xda, 0x3d, 0xe2, 0xdd, 0x86, 0x70, 0xe6, 0x32,
0x51, 0x54, 0x48, 0x01, 0x55, 0xbb, 0xee, 0xbb, 0x70, 0x2c, 0x75, 0x78, 0x1a, 0xc3, 0x2e,
0x13, 0x94, 0x18, 0x60, 0xcb, 0x57, 0x6f, 0xe3, 0x7a, 0x05, 0xb7, 0x57, 0xda, 0x5b, 0x5b,
0x41, 0x8f, 0x6d, 0xd7, 0xc3, 0x0b, 0x04, 0x2e, 0x40, 0xf4, 0x39, 0x5a, 0x34, 0x2a, 0xe4,
0xdc, 0xe0, 0x56, 0x34, 0xc3, 0x36, 0x25, 0xe2, 0xbc, 0x52, 0x43, 0x45, 0x48, 0x1f, 0x7e,
0x25, 0x3d, 0x95, 0x51, 0x26, 0x68, 0x23, 0x77, 0x1b, 0x25, 0x17, 0x05, 0xb4, 0xa8, 0x51,
0x66, 0x02, 0x2a, 0x37, 0xac, 0x28, 0xf1, 0xbd,
];
let hash = sha384(msg);
// ECDSAVS NIST test vector
let mut cmd = MailboxReq::EcdsaVerify(EcdsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key_x: [
0xcb, 0x90, 0x8b, 0x1f, 0xd5, 0x16, 0xa5, 0x7b, 0x8e, 0xe1, 0xe1, 0x43, 0x83, 0x57,
0x9b, 0x33, 0xcb, 0x15, 0x4f, 0xec, 0xe2, 0x0c, 0x50, 0x35, 0xe2, 0xb3, 0x76, 0x51,
0x95, 0xd1, 0x95, 0x1d, 0x75, 0xbd, 0x78, 0xfb, 0x23, 0xe0, 0x0f, 0xef, 0x37, 0xd7,
0xd0, 0x64, 0xfd, 0x9a, 0xf1, 0x44,
],
pub_key_y: [
0xcd, 0x99, 0xc4, 0x6b, 0x58, 0x57, 0x40, 0x1d, 0xdc, 0xff, 0x2c, 0xf7, 0xcf, 0x82,
0x21, 0x21, 0xfa, 0xf1, 0xcb, 0xad, 0x9a, 0x01, 0x1b, 0xed, 0x8c, 0x55, 0x1f, 0x6f,
0x59, 0xb2, 0xc3, 0x60, 0xf7, 0x9b, 0xfb, 0xe3, 0x2a, 0xdb, 0xca, 0xa0, 0x95, 0x83,
0xbd, 0xfd, 0xf7, 0xc3, 0x74, 0xbb,
],
signature_r: [
0x33, 0xf6, 0x4f, 0xb6, 0x5c, 0xd6, 0xa8, 0x91, 0x85, 0x23, 0xf2, 0x3a, 0xea, 0x0b,
0xbc, 0xf5, 0x6b, 0xba, 0x1d, 0xac, 0xa7, 0xaf, 0xf8, 0x17, 0xc8, 0x79, 0x1d, 0xc9,
0x24, 0x28, 0xd6, 0x05, 0xac, 0x62, 0x9d, 0xe2, 0xe8, 0x47, 0xd4, 0x3c, 0xee, 0x55,
0xba, 0x9e, 0x4a, 0x0e, 0x83, 0xba,
],
signature_s: [
0x44, 0x28, 0xbb, 0x47, 0x8a, 0x43, 0xac, 0x73, 0xec, 0xd6, 0xde, 0x51, 0xdd, 0xf7,
0xc2, 0x8f, 0xf3, 0xc2, 0x44, 0x16, 0x25, 0xa0, 0x81, 0x71, 0x43, 0x37, 0xdd, 0x44,
0xfe, 0xa8, 0x01, 0x1b, 0xae, 0x71, 0x95, 0x9a, 0x10, 0x94, 0x7b, 0x6e, 0xa3, 0x3f,
0x77, 0xe1, 0x28, 0xd3, 0xc6, 0xae,
],
hash,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::ECDSA384_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let resp_hdr: &MailboxRespHeader = MailboxRespHeader::ref_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(
resp_hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
// Checksum is just going to be 0 because FIPS_STATUS_APPROVED is 0
assert_eq!(resp_hdr.chksum, 0);
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0);
}
#[test]
fn test_ecdsa_verify_bad_chksum() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let cmd = MailboxReq::EcdsaVerify(EcdsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key_x: [0u8; 48],
pub_key_y: [0u8; 48],
signature_r: [0u8; 48],
signature_s: [0u8; 48],
hash: [0u8; 48],
});
let resp = model
.mailbox_execute(
u32::from(CommandId::ECDSA384_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_INVALID_CHECKSUM,
resp,
);
}
// HW errors are not supported on the SW emulator yet
#[cfg(any(
feature = "verilator",
feature = "fpga_realtime",
feature = "fpga_subsystem"
))]
#[test]
fn test_ecdsa_hw_failure() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let mut cmd = MailboxReq::EcdsaVerify(EcdsaVerifyReq {
hdr: MailboxReqHeader { chksum: 0 },
pub_key_x: [0u8; 48],
pub_key_y: [0u8; 48],
signature_r: [0xa5u8; 48],
signature_s: [0xa5u8; 48],
hash: [0x55u8; 48],
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::ECDSA384_SIGNATURE_VERIFY),
cmd.as_bytes().unwrap(),
)
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::DRIVER_ECC384_HW_ERROR,
resp,
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_stash_measurement.rs | runtime/tests/runtime_integration_tests/test_stash_measurement.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_builder::{
firmware::{APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::mailbox_api::{
CommandId, MailboxReq, MailboxReqHeader, StashMeasurementReq, StashMeasurementResp,
};
use caliptra_hw_model::HwModel;
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::RtBootStatus;
use sha2::{Digest, Sha384};
use zerocopy::{FromBytes, IntoBytes};
use crate::common::{run_rt_test, RuntimeTestArgs};
#[test]
fn test_stash_measurement() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let measurement = [1u8; 48];
let mut cmd = MailboxReq::StashMeasurement(StashMeasurementReq {
hdr: MailboxReqHeader { chksum: 0 },
metadata: [0u8; 4],
measurement,
context: [0u8; 48],
svn: 0,
});
cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let resp_hdr: &StashMeasurementResp =
StashMeasurementResp::ref_from_bytes(resp.as_bytes()).unwrap();
assert_eq!(resp_hdr.dpe_result, 0);
// create a new fw image with the runtime replaced by the mbox responder
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options,
)
.unwrap()
.to_bytes()
.unwrap();
// trigger an update reset so we can use commands in mbox responder
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let valid_pauser_hash_resp = model.mailbox_execute(0x2000_0000, &[]).unwrap().unwrap();
let valid_pauser_hash: [u8; 48] = valid_pauser_hash_resp.as_bytes().try_into().unwrap();
// hash expected DPE measurements in order to check that stashed measurement was added to DPE
let mut hasher = Sha384::new();
hasher.update(rt_journey_pcr);
hasher.update(valid_pauser_hash);
hasher.update(measurement);
let expected_measurement_hash = hasher.finalize();
let dpe_measurement_hash = model.mailbox_execute(0x3000_0000, &[]).unwrap().unwrap();
assert_eq!(expected_measurement_hash.as_bytes(), dpe_measurement_hash);
}
#[test]
fn test_pcr31_extended_upon_stash_measurement() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_fwid: Some(crate::test_update_reset::mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
// Read PCR_ID_STASH_MEASUREMENT
let pcr_31_resp = model.mailbox_execute(0x5000_0000, &[]).unwrap().unwrap();
let pcr_31: [u8; 48] = pcr_31_resp.as_bytes().try_into().unwrap();
// update reset to the real runtime image
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
&APP_WITH_UART,
image_options.clone(),
)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
// stash a measurement
let measurement = [2u8; 48];
let mut cmd = MailboxReq::StashMeasurement(StashMeasurementReq {
hdr: MailboxReqHeader { chksum: 0 },
metadata: [0u8; 4],
measurement,
context: [0u8; 48],
svn: 0,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::STASH_MEASUREMENT),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
// update reset back to mbox responder
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options.clone(),
)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
let updated_fw_image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options,
)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &updated_fw_image)
.unwrap();
// Read extended PCR_ID_STASH_MEASUREMENT
let extended_pcr_31_resp = model.mailbox_execute(0x5000_0000, &[]).unwrap().unwrap();
let extended_pcr_31: [u8; 48] = extended_pcr_31_resp.as_bytes().try_into().unwrap();
// no need to flip endianness here since PCRs are already in same endianness
// as sha2 hashes
let mut hasher = Sha384::new();
hasher.update(pcr_31);
hasher.update(measurement);
let expected_pcr_31 = hasher.finalize();
assert_eq!(expected_pcr_31.as_bytes(), extended_pcr_31);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_invoke_dpe.rs | runtime/tests/runtime_integration_tests/test_invoke_dpe.rs | // Licensed under the Apache-2.0 license.
use crate::common::{
execute_dpe_cmd, get_rt_alias_ecc384_cert, run_rt_test, DpeResult, RuntimeTestArgs,
TEST_DIGEST, TEST_LABEL,
};
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{
CommandId, FwInfoResp, InvokeDpeReq, MailboxReq, MailboxReqHeader,
};
use caliptra_drivers::CaliptraError;
use caliptra_hw_model::{HwModel, SecurityState};
use caliptra_runtime::{RtBootStatus, DPE_SUPPORT, VENDOR_ID, VENDOR_SKU};
use cms::{
cert::x509::der::{Decode, Encode},
content_info::{CmsVersion, ContentInfo},
signed_data::{SignedData, SignerIdentifier},
};
use dpe::{
commands::{
CertifyKeyCmd, CertifyKeyFlags, Command, DeriveContextCmd, DeriveContextFlags,
GetCertificateChainCmd, InitCtxCmd, RotateCtxCmd, RotateCtxFlags, SignCmd, SignFlags,
},
context::ContextHandle,
response::{DpeErrorCode, Response},
DPE_PROFILE,
};
use openssl::{
bn::BigNum,
ec::{EcGroup, EcKey},
ecdsa::EcdsaSig,
nid::Nid,
x509::X509,
};
use sha2::{Digest, Sha384};
use x509_parser::{nom::Parser, prelude::*};
use zerocopy::{FromBytes, IntoBytes};
#[test]
fn test_invoke_dpe_get_profile_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let resp = execute_dpe_cmd(&mut model, &mut Command::GetProfile, DpeResult::Success);
let Some(Response::GetProfile(profile)) = resp else {
panic!("Wrong response type!");
};
assert_eq!(profile.resp_hdr.profile, DPE_PROFILE);
assert_eq!(profile.vendor_id, VENDOR_ID);
assert_eq!(profile.vendor_sku, VENDOR_SKU);
assert_eq!(profile.flags, DPE_SUPPORT.bits());
assert_eq!(profile.max_tci_nodes, 32);
}
#[test]
fn test_invoke_dpe_size_too_big() {
// Test with data_size too big.
let mut cmd = MailboxReq::InvokeDpeCommand(InvokeDpeReq {
hdr: MailboxReqHeader { chksum: 0 },
data_size: InvokeDpeReq::DATA_MAX_SIZE as u32 + 1,
data: [0u8; InvokeDpeReq::DATA_MAX_SIZE],
});
assert_eq!(
cmd.populate_chksum(),
Err(CaliptraError::RUNTIME_MAILBOX_API_REQUEST_DATA_LEN_TOO_LARGE)
);
}
#[test]
fn test_invoke_dpe_get_certificate_chain_cmd() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let get_cert_chain_cmd = GetCertificateChainCmd {
offset: 0,
size: 2048,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::GetCertificateChain(&get_cert_chain_cmd),
DpeResult::Success,
);
let Some(Response::GetCertificateChain(cert_chain)) = resp else {
panic!("Wrong response type!");
};
assert_eq!(cert_chain.certificate_size, 2048);
assert_ne!([0u8; 2048], cert_chain.certificate_chain);
}
#[test]
fn test_invoke_dpe_sign_and_certify_key_cmds() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let sign_cmd = SignCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: SignFlags::empty(),
digest: TEST_DIGEST,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::Sign(&sign_cmd),
DpeResult::Success,
);
let Some(Response::Sign(sign_resp)) = resp else {
panic!("Wrong response type!");
};
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
let sig = EcdsaSig::from_private_components(
BigNum::from_slice(&sign_resp.sig_r).unwrap(),
BigNum::from_slice(&sign_resp.sig_s).unwrap(),
)
.unwrap();
let ecc_pub_key = EcKey::from_public_key_affine_coordinates(
&EcGroup::from_curve_name(Nid::SECP384R1).unwrap(),
&BigNum::from_slice(&certify_key_resp.derived_pubkey_x).unwrap(),
&BigNum::from_slice(&certify_key_resp.derived_pubkey_y).unwrap(),
)
.unwrap();
assert!(sig.verify(&TEST_DIGEST, &ecc_pub_key).unwrap());
}
#[test]
fn test_invoke_dpe_asymmetric_sign() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let sign_cmd = SignCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: SignFlags::empty(),
digest: TEST_DIGEST,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::Sign(&sign_cmd),
DpeResult::Success,
);
let Some(Response::Sign(sign_resp)) = resp else {
panic!("Wrong response type!");
};
assert_ne!(sign_resp.sig_r, [0u8; 48]);
assert_ne!(sign_resp.sig_s, [0u8; 48]);
}
#[test]
fn test_dpe_header_error_code() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// cannot initialize non-simulation contexts so expect DPE cmd to fail
let init_ctx_cmd = InitCtxCmd::new_use_default();
let resp = execute_dpe_cmd(
&mut model,
&mut Command::InitCtx(&init_ctx_cmd),
DpeResult::DpeCmdFailure,
);
let Some(Response::Error(hdr)) = resp else {
panic!("Wrong response type!");
};
assert_eq!(
hdr.status,
DpeErrorCode::ArgumentNotSupported.get_error_code()
);
}
#[test]
fn test_invoke_dpe_certify_key_csr() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_CSR,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(certify_key_resp)) = resp else {
panic!("Wrong response type!");
};
let rt_resp = get_rt_alias_ecc384_cert(&mut model);
let rt_cert: X509 = X509::from_der(&rt_resp.data[..rt_resp.data_size as usize]).unwrap();
// parse CMS ContentInfo
let content_info = ContentInfo::from_der(
&certify_key_resp.cert[..certify_key_resp.cert_size.try_into().unwrap()],
)
.unwrap();
// parse SignedData
let mut signed_data = SignedData::from_der(&content_info.content.to_der().unwrap()).unwrap();
assert_eq!(signed_data.version, CmsVersion::V3);
// validate signer infos
let signer_infos = signed_data.signer_infos.0;
// ensure there is only 1 signer info
assert_eq!(signer_infos.len(), 1);
let signer_info = signer_infos.get(0).unwrap();
assert_eq!(signer_info.version, CmsVersion::V3);
// validate signer identifier
let sid = &signer_info.sid;
match sid {
SignerIdentifier::SubjectKeyIdentifier(subject_key_identifier) => {
// skip first two bytes - first byte is 0x4 der encoding byte and second byte is size byte
let cert_ski = &subject_key_identifier.0.as_bytes()[2..];
let ski = rt_cert.subject_key_id().unwrap().as_slice();
assert_eq!(cert_ski, ski);
}
_ => panic!("Error: Signer Identifier is not SubjectKeyIdentifier!"),
};
// parse encapsulated content info
let econtent_info = &mut signed_data.encap_content_info;
// skip first 4 explicit encoding bytes
let econtent = &econtent_info.econtent.as_mut().unwrap().to_der().unwrap()[4..];
// validate csr signature with the alias key
let mut hasher = Sha384::new();
hasher.update(econtent);
let csr_digest = hasher.finalize();
let alias_key = rt_cert.public_key().unwrap().ec_key().unwrap();
let csr_sig = EcdsaSig::from_der(signer_info.signature.as_bytes()).unwrap();
assert!(csr_sig.verify(&csr_digest, &alias_key).unwrap());
}
#[test]
fn test_invoke_dpe_rotate_context() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let rotate_ctx_cmd = RotateCtxCmd {
handle: ContextHandle::default(),
flags: RotateCtxFlags::empty(),
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::RotateCtx(&rotate_ctx_cmd),
DpeResult::Success,
);
let Some(Response::RotateCtx(rotate_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
assert!(!rotate_ctx_resp.handle.is_default());
let rotate_ctx_cmd = RotateCtxCmd {
handle: rotate_ctx_resp.handle,
flags: RotateCtxFlags::TARGET_IS_DEFAULT,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::RotateCtx(&rotate_ctx_cmd),
DpeResult::Success,
);
let Some(Response::RotateCtx(rotate_ctx_resp)) = resp else {
panic!("Wrong response type!");
};
assert!(rotate_ctx_resp.handle.is_default());
}
fn check_dice_extension_criticality(cert: &[u8], expected_criticality: bool) {
let mut parser = X509CertificateParser::new().with_deep_parse_extensions(true);
let Ok((_, cert)) = parser.parse(cert) else {
panic!("Could not parse x509 certificate from CertifyKey!");
};
for extension in cert.iter_extensions() {
// Unknown extensions are DICE extensions, and they should match the
// criticality set by the DPE instance.
if extension.parsed_extension().unsupported() {
assert_eq!(extension.critical, expected_criticality);
}
}
}
#[test]
fn test_invoke_dpe_certify_key_with_non_critical_dice_extensions() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let certify_key_cmd = CertifyKeyCmd {
handle: ContextHandle::default(),
label: TEST_LABEL,
flags: CertifyKeyFlags::empty(),
format: CertifyKeyCmd::FORMAT_X509,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::CertifyKey(&certify_key_cmd),
DpeResult::Success,
);
let Some(Response::CertifyKey(resp)) = resp else {
panic!("Wrong response type!");
};
check_dice_extension_criticality(&resp.cert[..resp.cert_size.try_into().unwrap()], false);
}
#[test]
fn test_invoke_dpe_export_cdi_with_non_critical_dice_extensions() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let derive_ctx_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let resp = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
let Some(Response::DeriveContextExportedCdi(resp)) = resp else {
panic!("expected derive context resp!");
};
check_dice_extension_criticality(
&resp.new_certificate[..resp.certificate_size.try_into().unwrap()],
false,
);
}
#[test]
fn test_export_cdi_attestation_not_disabled_after_update_reset() {
let mut model = run_rt_test(RuntimeTestArgs {
security_state: Some(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Production)
.set_debug_locked(true),
),
..Default::default()
});
let derive_ctx_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
// Triggering a warm reset while a command is being processed will disable attestation.
for _ in 0..1000 {
model.step();
}
model.warm_reset_flow().unwrap();
// check attestation is not disabled via FW_INFO
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(info.attestation_disabled, 0);
}
#[test]
fn test_export_cdi_destroyed_root_context() {
let mut model = run_rt_test(RuntimeTestArgs {
security_state: Some(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Production)
.set_debug_locked(true),
),
..Default::default()
});
// You probably want to retain the parent context, otherwise the whole DPE chain _may be
// destroyed.
//
// This test case exercises that runtime cannot find the root context if the chain is
// destroyed.
let derive_ctx_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
// Triggering a warm reset while a command is being processed will disable attestation.
for _ in 0..1000 {
model.step();
}
model.warm_reset_flow().unwrap();
model.step_until_fatal_error(
CaliptraError::RUNTIME_UNABLE_TO_FIND_DPE_ROOT_CONTEXT.into(),
30_000_000,
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_warm_reset.rs | runtime/tests/runtime_integration_tests/test_warm_reset.rs | // Licensed under the Apache-2.0 license
use caliptra_api::soc_mgr::SocManager;
use caliptra_builder::{
firmware::{APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{
BootParams, DeviceLifecycle, Fuses, HwModel, InitParams, SecurityState, SubsystemInitParams,
};
use caliptra_test::image_pk_desc_hash;
use dpe::DPE_PROFILE;
#[test]
fn test_rt_journey_pcr_validation() {
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let fw_svn = 9;
let image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
ImageOptions {
fw_svn,
..Default::default()
},
)
.unwrap();
let (vendor_pk_desc_hash, owner_pk_hash) = image_pk_desc_hash(&image.manifest);
let binding = image.to_bytes().unwrap();
let soc_manifest = crate::common::default_soc_manifest_bytes(Default::default(), fw_svn);
let boot_params = BootParams {
fw_image: Some(&binding),
soc_manifest: Some(&soc_manifest),
mcu_fw_image: Some(&crate::common::DEFAULT_MCU_FW[..]),
..Default::default()
};
let mut model = caliptra_hw_model::new(
InitParams {
fuses: Fuses {
vendor_pk_hash: vendor_pk_desc_hash,
owner_pk_hash,
..Default::default()
},
rom: &rom,
security_state,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: cfg!(feature = "fpga_subsystem"),
..Default::default()
},
..Default::default()
},
boot_params.clone(),
)
.unwrap();
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let _ = model
.mailbox_execute(0xD000_0000, &[0u8; DPE_PROFILE.tci_size()])
.unwrap()
.unwrap();
// Perform warm reset
model.warm_reset_flow().unwrap();
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_RT_JOURNEY_PCR_VALIDATION_FAILED)
});
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
}
// TODO: https://github.com/chipsalliance/caliptra-sw/issues/2225
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_mbox_busy_during_warm_reset() {
// This test uses the mailbox responder binary to set the mailbox_flow_done register to
// false.
// A warm reset is then performed, since the mailbox responder binary never sets mailbox_flow_done
// to true, we verify that the mailbox_flow_done register remains false through the warm reset.
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
ImageOptions {
fw_svn: 9,
..Default::default()
},
)
.unwrap();
let (vendor_pk_desc_hash, owner_pk_hash) = image_pk_desc_hash(&image.manifest);
let binding = image.to_bytes().unwrap();
let boot_params = BootParams {
fw_image: Some(&binding),
..Default::default()
};
let mut model = caliptra_hw_model::new(
InitParams {
fuses: Fuses {
vendor_pk_hash: vendor_pk_desc_hash,
owner_pk_hash,
..Default::default()
},
rom: &rom,
security_state,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: cfg!(feature = "fpga_subsystem"),
..Default::default()
},
..Default::default()
},
boot_params.clone(),
)
.unwrap();
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
// 0xE000_0000 == OPCODE_HOLD_COMMAND_BUSY
model.mailbox_execute(0xE000_0000, &[]).unwrap();
assert!(!model
.soc_ifc()
.cptra_flow_status()
.read()
.mailbox_flow_done());
// Perform warm reset
model.warm_reset_flow().unwrap();
// Wait for boot
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().mailbox_flow_done());
assert_eq!(
model.soc_ifc().cptra_fw_error_non_fatal().read(),
u32::from(CaliptraError::RUNTIME_CMD_BUSY_DURING_WARM_RESET)
);
}
// TODO: https://github.com/chipsalliance/caliptra-sw/issues/2225
#[test]
#[cfg(not(any(feature = "fpga_realtime", feature = "fpga_subsystem")))]
fn test_mbox_idle_during_warm_reset() {
let security_state = *SecurityState::default()
.set_debug_locked(true)
.set_device_lifecycle(DeviceLifecycle::Production);
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let image = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
&APP_WITH_UART,
ImageOptions {
fw_svn: 9,
..Default::default()
},
)
.unwrap();
let (vendor_pk_desc_hash, owner_pk_hash) = image_pk_desc_hash(&image.manifest);
let binding = image.to_bytes().unwrap();
let boot_params = BootParams {
fw_image: Some(&binding),
..Default::default()
};
let mut model = caliptra_hw_model::new(
InitParams {
fuses: Fuses {
vendor_pk_hash: vendor_pk_desc_hash,
owner_pk_hash,
fw_svn: [0b1111111, 0, 0, 0],
..Default::default()
},
rom: &rom,
security_state,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: cfg!(feature = "fpga_subsystem"),
..Default::default()
},
..Default::default()
},
boot_params.clone(),
)
.unwrap();
// Wait for boot
model.step_until(|m| {
let status = m.soc_ifc().cptra_flow_status().read();
status.ready_for_runtime() && status.mailbox_flow_done()
});
// Perform warm reset
model.warm_reset_flow().unwrap();
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().mailbox_flow_done());
assert_ne!(
model.soc_ifc().cptra_fw_error_non_fatal().read(),
u32::from(CaliptraError::RUNTIME_CMD_BUSY_DURING_WARM_RESET)
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_info.rs | runtime/tests/runtime_integration_tests/test_info.rs | // Licensed under the Apache-2.0 license.
use crate::common::{default_soc_manifest_bytes, run_rt_test, RuntimeTestArgs};
use crate::common::{DEFAULT_MCU_FW, PQC_KEY_TYPE};
use caliptra_api::SocManager;
use caliptra_builder::{
firmware::{APP_WITH_UART, APP_WITH_UART_FPGA, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::{
capabilities::Capabilities,
mailbox_api::{
CapabilitiesResp, CommandId, FwInfoResp, GetIdevEcc384InfoResp, GetIdevMldsa87InfoResp,
MailboxReqHeader, MailboxRespHeader,
},
};
use caliptra_hw_model::{
BootParams, DefaultHwModel, Fuses, HwModel, InitParams, ModelError, SubsystemInitParams,
};
use caliptra_image_crypto::OsslCrypto as Crypto;
use caliptra_image_gen::ImageGenerator;
use caliptra_image_types::RomInfo;
use caliptra_runtime::RtBootStatus;
use core::mem::size_of;
use zerocopy::{FromBytes, IntoBytes};
fn find_rom_info(rom: &[u8]) -> Option<RomInfo> {
// RomInfo is 64-byte aligned and the last data in the ROM bin
// Iterate backwards by 64-byte increments (assumes rom size will always be 64 byte aligned)
for i in (0..rom.len() - 63).rev().step_by(64) {
let chunk = &rom[i..i + 64];
// Check if the chunk contains non-zero data
if chunk.iter().any(|&byte| byte != 0) {
// Found non-zero data, return RomInfo constructed from the data
if let Ok(rom_info) = RomInfo::read_from_bytes(&rom[i..i + size_of::<RomInfo>()]) {
return Some(rom_info);
}
}
}
// No non-zero data found
None
}
pub fn get_fwinfo(model: &mut DefaultHwModel) -> FwInfoResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
// Verify checksum and FIPS status
assert!(caliptra_common::checksum::verify_checksum(
info.hdr.chksum,
0x0,
&info.as_bytes()[core::mem::size_of_val(&info.hdr.chksum)..],
));
assert_eq!(
info.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
assert_eq!(info.attestation_disabled, 0);
info
}
#[test]
fn test_fw_info() {
let fpga = cfg!(feature = "fpga_subsystem");
let app = if fpga {
&APP_WITH_UART_FPGA
} else {
&APP_WITH_UART
};
let mcu_fw_image: Option<&[u8]> = if fpga {
Some(&DEFAULT_MCU_FW[..])
} else {
None
};
for pqc_key_type in PQC_KEY_TYPE.iter() {
let soc_manifest = if fpga {
Some(default_soc_manifest_bytes(*pqc_key_type, 1))
} else {
None
};
let mut image_opts = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
image_opts.vendor_config.pl0_pauser = Some(0x1);
image_opts.fmc_version = 0xaaaa;
image_opts.app_version = 0xbbbbbbbb;
let mut image_opts10 = image_opts.clone();
image_opts10.fw_svn = 10;
let image =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, app, image_opts10).unwrap();
// Set fuses
let owner_pub_key_hash = ImageGenerator::new(Crypto::default())
.owner_pubkey_digest(&image.manifest.preamble)
.unwrap();
let fuses = Fuses {
fuse_pqc_key_type: *pqc_key_type as u32,
owner_pk_hash: owner_pub_key_hash,
..Default::default()
};
// Cannot use run_rt_test since we need the rom and image to verify info
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let init_params = InitParams {
fuses,
rom: &rom,
subsystem_mode: fpga,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: true,
..Default::default()
},
..Default::default()
};
let mut model = caliptra_hw_model::new(
init_params,
BootParams {
fw_image: Some(&image.to_bytes().unwrap()),
soc_manifest: soc_manifest.as_deref(),
mcu_fw_image,
..Default::default()
},
)
.unwrap();
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let rom_info = find_rom_info(&rom).unwrap();
let get_fwinfo = |model: &mut DefaultHwModel| {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::FW_INFO),
&[],
),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
// Verify checksum and FIPS status
assert!(caliptra_common::checksum::verify_checksum(
info.hdr.chksum,
0x0,
&info.as_bytes()[core::mem::size_of_val(&info.hdr.chksum)..],
));
assert_eq!(
info.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
assert_eq!(info.attestation_disabled, 0);
info
};
let update_to = |model: &mut DefaultHwModel, image: &[u8]| {
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), image)
.unwrap();
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
};
let info = get_fwinfo(&mut model);
// Verify FW info
assert_eq!(info.pl0_pauser, 0x1);
assert_eq!(info.fw_svn, 10);
assert_eq!(info.min_fw_svn, 10);
// Verify revision (Commit ID) and digest of each component
assert_eq!(info.rom_revision, rom_info.revision);
assert_eq!(info.fmc_revision, image.manifest.fmc.revision);
assert_eq!(info.runtime_revision, image.manifest.runtime.revision);
assert_eq!(info.rom_sha256_digest, rom_info.sha256_digest);
assert_eq!(info.fmc_sha384_digest, image.manifest.fmc.digest);
assert_eq!(info.runtime_sha384_digest, image.manifest.runtime.digest);
assert_eq!(info.most_recent_fw_error, 0x0);
// Make image with newer SVN.
let mut image_opts20 = image_opts.clone();
image_opts20.fw_svn = 20;
let image20 = caliptra_builder::build_and_sign_image(&FMC_WITH_UART, app, image_opts20)
.unwrap()
.to_bytes()
.unwrap();
// Trigger an update reset.
update_to(&mut model, &image20);
let info = get_fwinfo(&mut model);
assert_eq!(info.fw_svn, 20);
assert_eq!(info.min_fw_svn, 10);
assert_eq!(info.cold_boot_fw_svn, 10);
// Make image with older SVN.
let mut image_opts5 = image_opts;
image_opts5.fw_svn = 5;
let image5 = caliptra_builder::build_and_sign_image(&FMC_WITH_UART, app, image_opts5)
.unwrap()
.to_bytes()
.unwrap();
update_to(&mut model, &image5);
let info = get_fwinfo(&mut model);
assert_eq!(info.fw_svn, 5);
assert_eq!(info.min_fw_svn, 5);
assert_eq!(info.cold_boot_fw_svn, 10);
// Go back to SVN 20
update_to(&mut model, &image20);
let info = get_fwinfo(&mut model);
assert_eq!(info.fw_svn, 20);
assert_eq!(info.min_fw_svn, 5);
assert_eq!(info.cold_boot_fw_svn, 10);
}
}
#[test]
fn test_fw_most_recent_fw_error() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let info = get_fwinfo(&mut model);
assert_eq!(info.most_recent_fw_error, 0);
// Inject a non-fatal FW error
// Generate an INVALID_CHECKSUM error
let invalid_chksum_err = u32::from(caliptra_drivers::CaliptraError::RUNTIME_INVALID_CHECKSUM);
// Send a command with an invalid checksum
let payload = MailboxReqHeader { chksum: 0xABCD };
let error = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap_err();
// Ensure the right non-fatal error was reported
if let ModelError::MailboxCmdFailed(code) = error {
assert_eq!(code, invalid_chksum_err);
} else {
panic!(
"Mailbox command should have failed with error {}, instead failed with {} error",
invalid_chksum_err, error
)
}
// Send another FW_INFO command
let info = get_fwinfo(&mut model);
// Fatal error should have been cleared by the new command
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0x0);
// Info should have still reported the old error
assert_eq!(info.most_recent_fw_error, invalid_chksum_err);
// Inject a different non-fatal FW error
// Generate an UNSUPPORTED_COMMAND error
let rt_unimplemented_cmd =
u32::from(caliptra_drivers::CaliptraError::RUNTIME_UNIMPLEMENTED_COMMAND);
// Send a command with an invalid opcode
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(0xABCD, &[]),
};
let error = model
.mailbox_execute(0xABCD, payload.as_bytes())
.unwrap_err();
// Ensure the right non-fatal error was reported
if let ModelError::MailboxCmdFailed(code) = error {
assert_eq!(code, rt_unimplemented_cmd);
} else {
panic!(
"Mailbox command should have failed with error {}, instead failed with {} error",
rt_unimplemented_cmd, error
)
}
// Send another FW_INFO command
let info = get_fwinfo(&mut model);
// Fatal error should have been cleared by the new command
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0x0);
// Info should have still reported the old error
assert_eq!(info.most_recent_fw_error, rt_unimplemented_cmd);
}
#[test]
fn test_idev_id_ecc384_info() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_ECC384_INFO),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_ECC384_INFO),
payload.as_bytes(),
)
.unwrap()
.unwrap();
GetIdevEcc384InfoResp::read_from_bytes(resp.as_slice()).unwrap();
}
#[test]
fn test_idev_id_mldsa87_info() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_IDEV_MLDSA87_INFO),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_IDEV_MLDSA87_INFO),
payload.as_bytes(),
)
.unwrap()
.unwrap();
GetIdevMldsa87InfoResp::read_from_bytes(resp.as_slice()).unwrap();
}
#[test]
fn test_capabilities() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::CAPABILITIES), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::CAPABILITIES), payload.as_bytes())
.unwrap()
.unwrap();
let capabilities_resp = CapabilitiesResp::read_from_bytes(resp.as_slice()).unwrap();
let capabilities = Capabilities::try_from(capabilities_resp.capabilities.as_bytes()).unwrap();
assert!(capabilities.contains(Capabilities::RT_BASE));
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_activate_firmware.rs | runtime/tests/runtime_integration_tests/test_activate_firmware.rs | // Licensed under the Apache-2.0 license
use crate::test_authorize_and_stash::set_auth_manifest_with_test_sram;
use crate::test_set_auth_manifest::create_auth_manifest_with_metadata;
use caliptra_api::mailbox::ActivateFirmwareReq;
use caliptra_auth_man_types::AuthManifestImageMetadata;
use caliptra_auth_man_types::{Addr64, ImageMetadataFlags};
use caliptra_common::mailbox_api::{
AuthorizeAndStashReq, AuthorizeAndStashResp, CommandId, ImageHashSource, MailboxReq,
MailboxReqHeader,
};
use caliptra_hw_model::{DefaultHwModel, HwModel, ModelError};
use caliptra_runtime::IMAGE_AUTHORIZED;
use sha2::{Digest, Sha384};
use zerocopy::FromBytes;
pub const TEST_SRAM_SIZE: usize = 64 * 1024; // 64 KB
#[cfg(feature = "fpga_subsystem")]
const MCI_BASE: u32 = 0xA8000000;
#[cfg(feature = "fpga_subsystem")]
const MCU_MBOX_SRAM_BASE: u32 = MCI_BASE + 0x400000;
#[cfg(feature = "fpga_subsystem")]
pub const TEST_SRAM_BASE: Addr64 = Addr64 {
lo: MCU_MBOX_SRAM_BASE,
hi: 0x0000_0000,
};
#[cfg(not(any(feature = "fpga_subsystem")))]
pub const TEST_SRAM_BASE: Addr64 = Addr64 {
lo: 0x0050_0000,
hi: 0x0000_0000,
};
pub const MCU_FW_ID_1: u32 = 0x2;
pub const SOC_FW_ID_1: u32 = 0x3;
pub const INVALID_FW_ID: u32 = 128;
pub const MCU_LOAD_ADDRESS: Addr64 = Addr64 {
lo: TEST_SRAM_BASE.lo,
hi: 0x0000_0000,
};
pub const MCU_STAGING_ADDRESS: Addr64 = Addr64 {
lo: TEST_SRAM_BASE.lo + 0x200,
hi: 0x0000_0000,
};
pub const SOC_LOAD_ADDRESS: Addr64 = Addr64 {
lo: TEST_SRAM_BASE.lo + 0x100,
hi: 0x0000_0000,
};
pub const SOC_STAGING_ADDRESS: Addr64 = Addr64 {
lo: TEST_SRAM_BASE.lo + 0x300,
hi: 0x0000_0000,
};
pub const MCU_FW_SIZE: usize = 256;
pub const SOC_FW_SIZE: usize = 256;
#[derive(Debug, Clone)]
struct Image {
pub fw_id: u32,
pub staging_address: Addr64,
pub load_address: Addr64,
pub exec_bit: u8,
pub contents: Vec<u8>,
}
fn load_and_authorize_fw(images: &[Image]) -> DefaultHwModel {
let mut image_metadata = Vec::new();
let mut test_sram_contents = vec![0u8; TEST_SRAM_SIZE];
for image in images {
let mut flags = ImageMetadataFlags(0);
flags.set_ignore_auth_check(false);
flags.set_image_source(ImageHashSource::StagingAddress as u32);
flags.set_exec_bit(image.exec_bit as u32);
let load_memory_contents = image.contents.clone();
let mut hasher = Sha384::new();
hasher.update(load_memory_contents);
let fw_digest = hasher.finalize();
image_metadata.push(AuthManifestImageMetadata {
fw_id: image.fw_id,
flags: flags.0,
digest: fw_digest.into(),
image_staging_address: image.staging_address,
image_load_address: image.load_address,
..Default::default()
});
// Load the firmware contents into the staging area in test SRAM
let staging_address = image.staging_address.lo as usize - TEST_SRAM_BASE.lo as usize;
let image_size = image.contents.len();
assert!(staging_address + image_size <= TEST_SRAM_SIZE);
test_sram_contents[staging_address..staging_address + image_size]
.copy_from_slice(&image.contents);
}
let auth_manifest = create_auth_manifest_with_metadata(image_metadata);
let mut model = set_auth_manifest_with_test_sram(
Some(auth_manifest),
&test_sram_contents,
&images[0].contents,
);
#[cfg(feature = "fpga_subsystem")]
{
crate::test_authorize_and_stash::write_mcu_mbox_sram(&mut model, &test_sram_contents);
}
for image in images {
let mut authorize_and_stash_cmd = MailboxReq::AuthorizeAndStash(AuthorizeAndStashReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id: image.fw_id.to_le_bytes(),
measurement: [0; 48],
source: ImageHashSource::StagingAddress as u32,
flags: 0, // Don't skip stash
image_size: image.contents.len() as u32,
..Default::default()
});
authorize_and_stash_cmd.populate_chksum().unwrap();
let resp = model
.mailbox_execute(
u32::from(CommandId::AUTHORIZE_AND_STASH),
authorize_and_stash_cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We should have received a response");
let authorize_and_stash_resp =
AuthorizeAndStashResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(authorize_and_stash_resp.auth_req_result, IMAGE_AUTHORIZED);
}
model
}
fn send_activate_firmware_cmd(
model: &mut DefaultHwModel,
activate_cmd: MailboxReq,
reset_expected: bool,
) -> std::result::Result<Option<Vec<u8>>, ModelError> {
model
.start_mailbox_execute(
u32::from(CommandId::ACTIVATE_FIRMWARE),
activate_cmd.as_bytes().unwrap(),
)
.unwrap();
#[cfg(feature = "fpga_subsystem")]
{
if reset_expected {
let clear_interrupt = |model: &mut DefaultHwModel| {
let mut retry_count = 10;
loop {
let intr_status = model
.mmio
.mci()
.unwrap()
.regs()
.intr_block_rf()
.notif0_internal_intr_r()
.read();
if intr_status.notif_cptra_mcu_reset_req_sts() {
break;
}
retry_count -= 1;
if retry_count == 0 {
return;
}
std::thread::sleep(std::time::Duration::from_millis(100));
}
model
.mmio
.mci()
.unwrap()
.regs()
.intr_block_rf()
.notif0_internal_intr_r()
.modify(|r| r.notif_cptra_mcu_reset_req_sts(true));
model
.mmio
.mci()
.unwrap()
.regs()
.reset_request()
.modify(|r| r.mcu_req(true));
};
// First interrupt is Caliptra requesting MCU reset
clear_interrupt(model);
// Second interrupt is Caliptra indicating FW is available
clear_interrupt(model);
}
}
#[cfg(all(
not(feature = "verilator"),
not(feature = "fpga_realtime"),
not(feature = "fpga_subsystem")
))]
{
if reset_expected {
// For sw-emulator, wait for the MCI interrupt to be set, then clear
// In a full subsystem, the MCU would do this
model.step_until(|m| m.mci.regs.borrow().intr_block_rf_notif0_internal_intr_r != 0);
const NOTIF_CPTRA_MCU_RESET_REQ_STS_MASK: u32 = 0x2;
model
.mci
.regs
.borrow_mut()
.intr_block_rf_notif0_internal_intr_r &= !NOTIF_CPTRA_MCU_RESET_REQ_STS_MASK;
}
}
model.finish_mailbox_execute()
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_activate_mcu_fw_success() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let mut model = load_and_authorize_fw(&[mcu_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 1,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = MCU_FW_ID_1;
arr
},
});
activate_cmd.populate_chksum().unwrap();
send_activate_firmware_cmd(&mut model, activate_cmd, true)
.unwrap()
.expect("We should have received a response");
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_activate_mcu_soc_fw_success() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let soc_image = Image {
fw_id: SOC_FW_ID_1,
staging_address: SOC_STAGING_ADDRESS,
load_address: SOC_LOAD_ADDRESS,
contents: [0xAAu8; SOC_FW_SIZE].to_vec(),
exec_bit: 3,
};
let mut model = load_and_authorize_fw(&[mcu_image, soc_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 2,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = MCU_FW_ID_1;
arr[1] = SOC_FW_ID_1;
arr
},
});
activate_cmd.populate_chksum().unwrap();
send_activate_firmware_cmd(&mut model, activate_cmd, true)
.unwrap()
.expect("We should have received a response");
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_activate_soc_fw_success() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let soc_image = Image {
fw_id: SOC_FW_ID_1,
staging_address: SOC_STAGING_ADDRESS,
load_address: SOC_LOAD_ADDRESS,
contents: [0xAAu8; SOC_FW_SIZE].to_vec(),
exec_bit: 3,
};
let mut model = load_and_authorize_fw(&[mcu_image, soc_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 1,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = SOC_FW_ID_1;
arr
},
});
activate_cmd.populate_chksum().unwrap();
send_activate_firmware_cmd(&mut model, activate_cmd, false)
.unwrap()
.expect("We should have received a response");
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_activate_invalid_fw_id() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let soc_image = Image {
fw_id: SOC_FW_ID_1,
staging_address: SOC_STAGING_ADDRESS,
load_address: SOC_LOAD_ADDRESS,
contents: [0xAAu8; SOC_FW_SIZE].to_vec(),
exec_bit: 3,
};
let mut model = load_and_authorize_fw(&[mcu_image, soc_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 1,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = INVALID_FW_ID;
arr
},
});
activate_cmd.populate_chksum().unwrap();
assert!(send_activate_firmware_cmd(&mut model, activate_cmd, false).is_err());
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_activate_fw_id_not_in_manifest() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let soc_image = Image {
fw_id: SOC_FW_ID_1,
staging_address: SOC_STAGING_ADDRESS,
load_address: SOC_LOAD_ADDRESS,
contents: [0xAAu8; SOC_FW_SIZE].to_vec(),
exec_bit: 3,
};
let mut model = load_and_authorize_fw(&[mcu_image, soc_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 1,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = INVALID_FW_ID;
arr
},
});
activate_cmd.populate_chksum().unwrap();
assert!(send_activate_firmware_cmd(&mut model, activate_cmd, false).is_err());
}
#[cfg_attr(feature = "fpga_realtime", ignore)]
#[test]
fn test_invalid_exec_bit_in_manifest() {
let mcu_image = Image {
fw_id: MCU_FW_ID_1,
staging_address: MCU_STAGING_ADDRESS,
load_address: MCU_LOAD_ADDRESS,
contents: [0x55u8; MCU_FW_SIZE].to_vec(),
exec_bit: 2,
};
let soc_image = Image {
fw_id: SOC_FW_ID_1,
staging_address: SOC_STAGING_ADDRESS,
load_address: SOC_LOAD_ADDRESS,
contents: [0xAAu8; SOC_FW_SIZE].to_vec(),
exec_bit: 0,
};
let mut model = load_and_authorize_fw(&[mcu_image, soc_image]);
// Send ActivateFirmware command
let mut activate_cmd = MailboxReq::ActivateFirmware(ActivateFirmwareReq {
hdr: MailboxReqHeader { chksum: 0 },
fw_id_count: 1,
mcu_fw_image_size: MCU_FW_SIZE as u32,
fw_ids: {
let mut arr = [0u32; 128];
arr[0] = SOC_FW_ID_1;
arr
},
});
activate_cmd.populate_chksum().unwrap();
assert!(send_activate_firmware_cmd(&mut model, activate_cmd, false).is_err());
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/main.rs | runtime/tests/runtime_integration_tests/main.rs | // Licensed under the Apache-2.0 license
mod common;
mod test_activate_firmware;
mod test_authorize_and_stash;
mod test_boot;
mod test_cap_warmreset;
mod test_capabilities;
mod test_certify_key_extended;
mod test_certs;
mod test_certs_384_warmreset;
mod test_cryptographic_mailbox;
mod test_debug_unlock;
mod test_disable;
mod test_ecdsa;
mod test_fe_programming;
mod test_fips;
mod test_firmware_verify;
mod test_get_fmc_alias_csr;
mod test_get_idev_csr;
mod test_get_image_info;
mod test_info;
mod test_invoke_dpe;
mod test_lms;
mod test_mailbox;
mod test_mldsa;
mod test_ocp_lock;
mod test_panic_missing;
mod test_pauser_privilege_levels;
mod test_pcr;
mod test_populate_idev;
mod test_reallocate_dpe_context_limits;
mod test_recovery_flow;
mod test_revoke_exported_cdi_handle;
mod test_set_auth_manifest;
mod test_sign_with_export_ecdsa;
mod test_stash_measurement;
mod test_tagging;
mod test_update_reset;
mod test_warm_reset;
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/common.rs | runtime/tests/runtime_integration_tests/common.rs | // Licensed under the Apache-2.0 license
use caliptra_api::{
mailbox::{GetFmcAliasMlDsa87CertResp, Request},
SocManager,
};
use caliptra_builder::{
firmware::{
APP_WITH_UART, APP_WITH_UART_FPGA, APP_WITH_UART_OCP_LOCK, APP_WITH_UART_OCP_LOCK_FPGA,
FMC_WITH_UART,
},
FwId, ImageOptions,
};
use caliptra_common::{
mailbox_api::{
CommandId, GetFmcAliasEcc384CertResp, GetLdevCertResp, GetRtAliasCertResp, InvokeDpeReq,
InvokeDpeResp, MailboxReq, MailboxReqHeader,
},
memory_layout::{ROM_ORG, ROM_SIZE, ROM_STACK_ORG, ROM_STACK_SIZE, STACK_ORG, STACK_SIZE},
FMC_ORG, FMC_SIZE, RUNTIME_ORG, RUNTIME_SIZE,
};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_drivers::MfgFlags;
use caliptra_error::CaliptraError;
use caliptra_hw_model::{
BootParams, CodeRange, DefaultHwModel, DeviceLifecycle, Fuses, HwModel, ImageInfo, InitParams,
ModelCallback, ModelError, SecurityState, StackInfo, StackRange, SubsystemInitParams,
};
pub use caliptra_test::{
default_soc_manifest_bytes, image_pk_desc_hash, test_upload_firmware, DEFAULT_MCU_FW,
};
use dpe::{
commands::{Command, CommandHdr, DeriveContextCmd, DeriveContextFlags},
response::{
CertifyKeyResp, DeriveContextExportedCdiResp, DeriveContextResp, DpeErrorCode,
GetCertificateChainResp, GetProfileResp, NewHandleResp, Response, ResponseHdr, SignResp,
},
DPE_PROFILE,
};
use openssl::{
asn1::{Asn1Integer, Asn1Time, Asn1TimeRef},
bn::BigNum,
hash::MessageDigest,
pkey::{PKey, Private},
x509::{X509Builder, X509},
x509::{X509Name, X509NameBuilder},
};
use std::borrow::Cow;
use std::io;
use zerocopy::{FromZeros, IntoBytes, TryFromBytes};
pub const TEST_LABEL: [u8; 48] = [
48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25,
24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
];
pub const TEST_DIGEST: [u8; 48] = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
];
pub const DEFAULT_FMC_VERSION: u16 = 0xaaaa;
pub const DEFAULT_APP_VERSION: u32 = 0xbbbbbbbb;
pub const PQC_KEY_TYPE: [FwVerificationPqcKeyType; 2] = [
FwVerificationPqcKeyType::LMS,
FwVerificationPqcKeyType::MLDSA,
];
#[derive(Default)]
pub struct RuntimeProductionArgs {
pub fmc_version: u16,
pub app_version: u32,
pub fw_svn: u32,
}
pub struct RuntimeTestArgs<'a> {
pub test_fwid: Option<&'static FwId<'static>>,
pub test_fmc_fwid: Option<&'static FwId<'static>>,
pub test_image_options: Option<ImageOptions>,
pub init_params: Option<InitParams<'a>>,
pub test_mfg_flags: Option<MfgFlags>,
// SoC manifest passed via the recovery interface
pub soc_manifest: Option<&'a [u8]>,
// MCU firmware image passed via the recovery interface
pub mcu_fw_image: Option<&'a [u8]>,
/// Initial content of the test SRAM
pub test_sram: Option<&'a [u8]>,
pub stop_at_rom: bool,
pub security_state: Option<SecurityState>,
pub production_state: Option<RuntimeProductionArgs>,
pub soc_manifest_svn: Option<u32>,
pub soc_manifest_max_svn: Option<u32>,
pub hek_seed: Option<[u32; 8]>,
pub subsystem_mode: bool,
pub successful_reach_rt: bool,
pub ocp_lock_en: bool,
pub key_type: Option<FwVerificationPqcKeyType>,
pub rom_callback: Option<ModelCallback>,
}
impl RuntimeTestArgs<'_> {
// A handy shortcut for testing production
pub fn test_productions_args() -> RuntimeTestArgs<'static> {
let mut sec_state = SecurityState::default();
sec_state.set_debug_locked(true);
sec_state.set_device_lifecycle(DeviceLifecycle::Production);
RuntimeTestArgs {
security_state: Some(sec_state),
production_state: Some(RuntimeProductionArgs {
fmc_version: 3,
app_version: 5,
fw_svn: 9,
}),
..Default::default()
}
}
}
// clippy gets confused about cfg(feature = "...")
#[allow(clippy::derivable_impls)]
impl Default for RuntimeTestArgs<'_> {
fn default() -> Self {
Self {
test_fwid: None,
test_fmc_fwid: None,
test_image_options: None,
init_params: None,
test_mfg_flags: None,
soc_manifest: None,
mcu_fw_image: None,
test_sram: None,
stop_at_rom: false,
security_state: None,
production_state: None,
soc_manifest_svn: None,
soc_manifest_max_svn: None,
hek_seed: None,
subsystem_mode: cfg!(feature = "fpga_subsystem"),
successful_reach_rt: true,
ocp_lock_en: cfg!(feature = "ocp-lock"),
key_type: None,
rom_callback: None,
}
}
}
pub fn run_rt_test_pqc(
args: RuntimeTestArgs,
pqc_key_type: FwVerificationPqcKeyType,
) -> DefaultHwModel {
let successful_reach_rt = args.successful_reach_rt;
let mut model = start_rt_test_pqc_model(args, pqc_key_type).0;
if successful_reach_rt {
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
} else {
model.step_until(|m| {
m.soc_ifc()
.cptra_flow_status()
.read()
.ready_for_mb_processing()
});
}
model
}
pub const fn svn_to_bitmap(svn: u32) -> [u32; 4] {
let n = if svn > 128 { 128 } else { svn };
// Build a 128-bit value with the lowest `n` bits set.
// Shifting by 128 is invalid, so handle that case explicitly.
let val: u128 = if n == 0 {
0
} else if n == 128 {
u128::MAX
} else {
(1u128 << n) - 1
};
[
(val & 0xffff_ffff) as u32,
((val >> 32) & 0xffff_ffff) as u32,
((val >> 64) & 0xffff_ffff) as u32,
((val >> 96) & 0xffff_ffff) as u32,
]
}
pub fn rom_for_fw_integration_tests() -> io::Result<Cow<'static, [u8]>> {
caliptra_builder::rom_for_fw_integration_tests_fpga(cfg!(feature = "fpga_subsystem"))
}
pub fn start_rt_test_pqc_model(
args: RuntimeTestArgs,
pqc_key_type: FwVerificationPqcKeyType,
) -> (DefaultHwModel, Vec<u8>) {
let fpga = cfg!(any(feature = "fpga_realtime", feature = "fpga_subsystem"));
let ocp_lock = cfg!(feature = "ocp-lock");
let default_rt_fwid = match (fpga, ocp_lock) {
(false, false) => &APP_WITH_UART,
(true, false) => &APP_WITH_UART_FPGA,
(false, true) => &APP_WITH_UART_OCP_LOCK,
(true, true) => &APP_WITH_UART_OCP_LOCK_FPGA,
};
let runtime_fwid = args.test_fwid.unwrap_or(default_rt_fwid);
let fmc_fwid = args.test_fmc_fwid.unwrap_or(&FMC_WITH_UART);
let production_state = args.production_state.unwrap_or(RuntimeProductionArgs {
fmc_version: DEFAULT_FMC_VERSION,
app_version: DEFAULT_APP_VERSION,
fw_svn: Default::default(),
});
let image_options = args.test_image_options.unwrap_or_else(|| {
let mut opts = ImageOptions::default();
opts.vendor_config.pl0_pauser = Some(0x1);
opts.fmc_version = production_state.fmc_version;
opts.app_version = production_state.app_version;
opts.fw_svn = production_state.fw_svn;
opts.pqc_key_type = pqc_key_type;
opts
});
let image_info = vec![
ImageInfo::new(
StackRange::new(ROM_STACK_ORG + ROM_STACK_SIZE, ROM_STACK_ORG),
CodeRange::new(ROM_ORG, ROM_ORG + ROM_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(FMC_ORG, FMC_ORG + FMC_SIZE),
),
ImageInfo::new(
StackRange::new(STACK_ORG + STACK_SIZE, STACK_ORG),
CodeRange::new(RUNTIME_ORG, RUNTIME_ORG + RUNTIME_SIZE),
),
];
let rom = rom_for_fw_integration_tests().unwrap();
let image =
caliptra_builder::build_and_sign_image(fmc_fwid, runtime_fwid, image_options).unwrap();
let (vendor_pk_hash, owner_pk_hash) = image_pk_desc_hash(&image.manifest);
let mut init_params = args.init_params.unwrap_or_else(|| InitParams {
rom: &rom,
stack_info: Some(StackInfo::new(image_info)),
test_sram: args.test_sram,
security_state: args.security_state.unwrap_or_default(),
subsystem_mode: args.subsystem_mode,
ocp_lock_en: args.ocp_lock_en,
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: args.subsystem_mode,
..Default::default()
},
rom_callback: args.rom_callback,
..Default::default()
});
init_params.fuses = Fuses {
fuse_pqc_key_type: pqc_key_type as u32,
vendor_pk_hash,
owner_pk_hash,
soc_manifest_svn: svn_to_bitmap(args.soc_manifest_svn.unwrap_or(0)),
soc_manifest_max_svn: args.soc_manifest_max_svn.unwrap_or(127) as u8,
fw_svn: svn_to_bitmap(production_state.fw_svn),
hek_seed: args.hek_seed.unwrap_or([0xABDEu32; 8]),
..Default::default()
};
let boot_flags = if let Some(flags) = args.test_mfg_flags {
flags.bits()
} else {
0
};
let image = image.to_bytes().unwrap();
let default_manifest_bytes;
let (soc_manifest, mcu_fw_image) = if args.subsystem_mode && args.soc_manifest.is_none() {
default_manifest_bytes =
default_soc_manifest_bytes(pqc_key_type, args.soc_manifest_svn.unwrap_or(0));
(Some(&default_manifest_bytes[..]), Some(&DEFAULT_MCU_FW[..]))
} else {
(args.soc_manifest, args.mcu_fw_image)
};
let model = caliptra_hw_model::new(
init_params,
BootParams {
fw_image: if args.stop_at_rom { None } else { Some(&image) },
initial_dbg_manuf_service_reg: boot_flags,
soc_manifest,
mcu_fw_image,
..Default::default()
},
)
.unwrap();
(model, image)
}
// Run a test which boots ROM -> FMC -> test_bin. If test_bin_name is None,
// run the production runtime image.
pub fn run_rt_test(args: RuntimeTestArgs) -> DefaultHwModel {
// TODO(clundin): Do we want to use MLDSA by default in 2.1?
let key_type = args.key_type.unwrap_or(FwVerificationPqcKeyType::LMS);
run_rt_test_pqc(args, key_type)
}
pub fn generate_test_x509_cert(private_key: &PKey<Private>) -> X509 {
let mut cert_builder = X509Builder::new().unwrap();
cert_builder.set_version(2).unwrap();
cert_builder
.set_serial_number(&Asn1Integer::from_bn(&BigNum::from_u32(1).unwrap()).unwrap())
.unwrap();
let mut subj_name_builder: X509NameBuilder = X509Name::builder().unwrap();
subj_name_builder
.append_entry_by_text("CN", "example.com")
.unwrap();
let subject_name = X509NameBuilder::build(subj_name_builder);
cert_builder.set_subject_name(&subject_name).unwrap();
cert_builder.set_issuer_name(&subject_name).unwrap();
cert_builder.set_pubkey(private_key).unwrap();
cert_builder
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
.unwrap();
cert_builder
.set_not_after(&Asn1Time::days_from_now(365).unwrap())
.unwrap();
// Use appropriate message digest based on key type
let digest = match private_key.id() {
openssl::pkey::Id::EC => MessageDigest::sha384(),
_ => MessageDigest::null(), // For MLDSA and other key types
};
cert_builder.sign(private_key, digest).unwrap();
cert_builder.build()
}
fn get_cmd_id(dpe_cmd: &mut Command) -> u32 {
match dpe_cmd {
Command::GetProfile => Command::GET_PROFILE,
Command::InitCtx(_) => Command::INITIALIZE_CONTEXT,
Command::DeriveContext(_) => Command::DERIVE_CONTEXT,
Command::CertifyKey(_) => Command::CERTIFY_KEY,
Command::Sign(_) => Command::SIGN,
Command::RotateCtx(_) => Command::ROTATE_CONTEXT_HANDLE,
Command::DestroyCtx(_) => Command::DESTROY_CONTEXT,
Command::GetCertificateChain(_) => Command::GET_CERTIFICATE_CHAIN,
}
}
fn as_bytes<'a>(dpe_cmd: &'a mut Command) -> &'a [u8] {
match dpe_cmd {
Command::CertifyKey(cmd) => cmd.as_bytes(),
Command::DeriveContext(cmd) => cmd.as_bytes(),
Command::GetCertificateChain(cmd) => cmd.as_bytes(),
Command::DestroyCtx(cmd) => cmd.as_bytes(),
Command::GetProfile => &[],
Command::InitCtx(cmd) => cmd.as_bytes(),
Command::RotateCtx(cmd) => cmd.as_bytes(),
Command::Sign(cmd) => cmd.as_bytes(),
}
}
fn check_dpe_status(resp_bytes: &[u8], expected_status: DpeErrorCode) {
if let Ok(&ResponseHdr { status, .. }) =
ResponseHdr::try_ref_from_bytes(&resp_bytes[..core::mem::size_of::<ResponseHdr>()])
{
if status != expected_status.get_error_code() {
panic!("Unexpected DPE Status: 0x{:X}", status);
}
}
}
fn parse_dpe_response(dpe_cmd: &mut Command, resp_bytes: &[u8]) -> Response {
// Peek response header so we can panic with an error code in case the command failed.
check_dpe_status(resp_bytes, DpeErrorCode::NoError);
match dpe_cmd {
Command::CertifyKey(_) => {
Response::CertifyKey(CertifyKeyResp::try_read_from_bytes(resp_bytes).unwrap())
}
Command::DeriveContext(DeriveContextCmd { flags, .. })
if flags.contains(DeriveContextFlags::EXPORT_CDI) =>
{
Response::DeriveContextExportedCdi(
DeriveContextExportedCdiResp::try_read_from_bytes(resp_bytes).unwrap(),
)
}
Command::DeriveContext(_) => {
Response::DeriveContext(DeriveContextResp::try_read_from_bytes(resp_bytes).unwrap())
}
Command::GetCertificateChain(_) => Response::GetCertificateChain(
GetCertificateChainResp::try_read_from_bytes(resp_bytes).unwrap(),
),
Command::DestroyCtx(_) => {
Response::DestroyCtx(ResponseHdr::try_read_from_bytes(resp_bytes).unwrap())
}
Command::GetProfile => {
Response::GetProfile(GetProfileResp::try_read_from_bytes(resp_bytes).unwrap())
}
Command::InitCtx(_) => {
Response::InitCtx(NewHandleResp::try_read_from_bytes(resp_bytes).unwrap())
}
Command::RotateCtx(_) => {
Response::RotateCtx(NewHandleResp::try_read_from_bytes(resp_bytes).unwrap())
}
Command::Sign(_) => Response::Sign(SignResp::try_read_from_bytes(resp_bytes).unwrap()),
}
}
pub enum DpeResult {
Success,
DpeCmdFailure,
MboxCmdFailure(CaliptraError),
}
pub fn execute_dpe_cmd(
model: &mut DefaultHwModel,
dpe_cmd: &mut Command,
expected_result: DpeResult,
) -> Option<Response> {
let mut cmd_data: [u8; 512] = [0u8; InvokeDpeReq::DATA_MAX_SIZE];
let dpe_cmd_id = get_cmd_id(dpe_cmd);
let cmd_hdr = CommandHdr::new(DPE_PROFILE, dpe_cmd_id);
let cmd_hdr_buf = cmd_hdr.as_bytes();
cmd_data[..cmd_hdr_buf.len()].copy_from_slice(cmd_hdr_buf);
let dpe_cmd_buf = as_bytes(dpe_cmd);
cmd_data[cmd_hdr_buf.len()..cmd_hdr_buf.len() + dpe_cmd_buf.len()].copy_from_slice(dpe_cmd_buf);
let mut mbox_cmd = MailboxReq::InvokeDpeCommand(InvokeDpeReq {
hdr: MailboxReqHeader { chksum: 0 },
data: cmd_data,
data_size: (cmd_hdr_buf.len() + dpe_cmd_buf.len()) as u32,
});
mbox_cmd.populate_chksum().unwrap();
let resp = model.mailbox_execute(
u32::from(CommandId::INVOKE_DPE),
mbox_cmd.as_bytes().unwrap(),
);
if let DpeResult::MboxCmdFailure(expected_err) = expected_result {
assert_error(model, expected_err, resp.unwrap_err());
return None;
}
let resp = resp.unwrap().expect("We should have received a response");
assert!(resp.len() <= std::mem::size_of::<InvokeDpeResp>());
let mut resp_hdr = InvokeDpeResp::default();
resp_hdr.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
assert!(caliptra_common::checksum::verify_checksum(
resp_hdr.hdr.chksum,
0x0,
&resp[core::mem::size_of_val(&resp_hdr.hdr.chksum)..],
));
let resp_bytes = &resp_hdr.data[..resp_hdr.data_size as usize];
Some(match expected_result {
DpeResult::Success => parse_dpe_response(dpe_cmd, resp_bytes),
DpeResult::DpeCmdFailure => Response::Error(ResponseHdr::try_read_from_bytes(resp_bytes).unwrap()),
DpeResult::MboxCmdFailure(_) => unreachable!("If MboxCmdFailure is the expected DPE result, the function would have returned None earlier."),
})
}
pub fn assert_error(
model: &mut DefaultHwModel,
expected_err: CaliptraError,
actual_err: ModelError,
) {
assert_eq!(
model.soc_ifc().cptra_fw_error_non_fatal().read(),
u32::from(expected_err)
);
if let ModelError::MailboxCmdFailed(code) = actual_err {
assert_eq!(code, u32::from(expected_err));
} else {
panic!("Mailbox command should have failed with MailboxCmdFailed error, instead failed with {} error", actual_err)
}
}
pub fn get_certs<R: Request>(model: &mut DefaultHwModel) -> R::Resp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(R::ID), &[]),
};
let resp_data = model
.mailbox_execute(u32::from(R::ID), payload.as_bytes())
.unwrap()
.unwrap();
assert!(resp_data.len() <= std::mem::size_of::<<R as Request>::Resp>());
let mut resp = R::Resp::new_zeroed();
resp.as_mut_bytes()[..resp_data.len()].copy_from_slice(&resp_data);
resp
}
pub fn get_ecc_fmc_alias_cert(model: &mut DefaultHwModel) -> GetFmcAliasEcc384CertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_FMC_ALIAS_ECC384_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_FMC_ALIAS_ECC384_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetFmcAliasEcc384CertResp>());
let mut fmc_resp = GetFmcAliasEcc384CertResp::default();
fmc_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
fmc_resp
}
pub fn get_mldsa_fmc_alias_cert(model: &mut DefaultHwModel) -> GetFmcAliasMlDsa87CertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_FMC_ALIAS_MLDSA87_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_FMC_ALIAS_MLDSA87_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetFmcAliasMlDsa87CertResp>());
let mut fmc_resp = GetFmcAliasMlDsa87CertResp::default();
fmc_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
fmc_resp
}
pub fn get_rt_alias_ecc384_cert(model: &mut DefaultHwModel) -> GetRtAliasCertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_RT_ALIAS_ECC384_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_RT_ALIAS_ECC384_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetRtAliasCertResp>());
let mut rt_resp = GetRtAliasCertResp::default();
rt_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
rt_resp
}
pub fn get_rt_alias_mldsa87_cert(model: &mut DefaultHwModel) -> GetLdevCertResp {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::GET_RT_ALIAS_MLDSA87_CERT),
&[],
),
};
let resp = model
.mailbox_execute(
u32::from(CommandId::GET_RT_ALIAS_MLDSA87_CERT),
payload.as_bytes(),
)
.unwrap()
.unwrap();
assert!(resp.len() <= std::mem::size_of::<GetLdevCertResp>());
let mut rt_resp = GetLdevCertResp::default();
rt_resp.as_mut_bytes()[..resp.len()].copy_from_slice(&resp);
rt_resp
}
#[allow(dead_code)]
/// Compare two X509 certs by semantic fields rather than raw bytes.
pub fn assert_x509_semantic_eq(a: &X509, b: &X509) {
// Issuer / Subject
assert_eq!(
a.issuer_name().entries().count(),
b.issuer_name().entries().count(),
"issuer entry count mismatch"
);
assert_eq!(
a.issuer_name().to_der().unwrap(),
b.issuer_name().to_der().unwrap(),
"issuer differs"
);
assert_eq!(
a.subject_name().entries().count(),
b.subject_name().entries().count(),
"subject entry count mismatch"
);
assert_eq!(
a.subject_name().to_der().unwrap(),
b.subject_name().to_der().unwrap(),
"subject differs"
);
// Serial number
let a_sn = a.serial_number().to_bn().unwrap().to_vec();
let b_sn = b.serial_number().to_bn().unwrap().to_vec();
assert_eq!(a_sn, b_sn, "serial number differs");
// Public key
let a_pk = a.public_key().unwrap().public_key_to_der().unwrap();
let b_pk = b.public_key().unwrap().public_key_to_der().unwrap();
assert_eq!(a_pk, b_pk, "public key differs");
// Signature algorithm OID (not the signature value)
let a_sig_oid = a.signature_algorithm().object().nid();
let b_sig_oid = b.signature_algorithm().object().nid();
assert_eq!(a_sig_oid, b_sig_oid, "signature algorithm differs");
//check validity
assert_same_time(a.not_before(), b.not_before(), "notBefore");
assert_same_time(a.not_after(), b.not_after(), "notAfter");
}
#[allow(dead_code)]
fn assert_same_time(a: &Asn1TimeRef, b: &Asn1TimeRef, label: &str) {
let d = a.diff(b).expect("ASN.1 time diff failed");
// Equal iff day delta is 0 and second deltas is less than 10
// Must be the same day
assert_eq!(
d.days, 0,
"{label} differs by {} days, {} secs",
d.days, d.secs
);
// Seconds delta allowed up to 10
assert!(
d.secs.abs() <= 10,
"{label} differs by {} secs (allowed ≤ 10)",
d.secs
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_boot.rs | runtime/tests/runtime_integration_tests/test_boot.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_builder::{
firmware::{self, APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::mailbox_api::{CommandId, MailboxReq, MailboxReqHeader, StashMeasurementReq};
use caliptra_hw_model::{
BootParams, Fuses, HwModel, InitParams, SecurityState, SubsystemInitParams,
};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::RtBootStatus;
use sha2::{Digest, Sha384};
use zerocopy::IntoBytes;
use crate::common::{
run_rt_test, RuntimeTestArgs, DEFAULT_APP_VERSION, DEFAULT_FMC_VERSION, PQC_KEY_TYPE,
};
const RT_READY_FOR_COMMANDS: u32 = 0x600;
#[test]
fn test_standard() {
// Test that the normal runtime firmware boots.
// Ultimately, this will be useful for exercising Caliptra end-to-end
// via the mailbox.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
}
#[test]
fn test_boot() {
let args = RuntimeTestArgs {
test_fwid: Some(&firmware::runtime_tests::BOOT),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until_exit_success().unwrap();
}
#[test]
/// This test differs from the drivers' test_persistent() in that it is ran with the "runtime" flag so
/// it allows us to test conditionally compiled runtime-only persistent data that ROM/FMC may have corrupted.
fn test_persistent_data() {
let args = RuntimeTestArgs {
test_fwid: Some(&firmware::runtime_tests::PERSISTENT_RT),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until_exit_success().unwrap();
}
#[test]
fn test_fw_version() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let fw_rev = model.soc_ifc().cptra_fw_rev_id().read();
// fw_rev[0] is FMC version at 31:16 and ROM version at 15:0
// Ignore ROM version since this test is for runtime
assert_eq!(
fw_rev[0] & 0xFFFF0000, // Mask out the ROM version
(DEFAULT_FMC_VERSION as u32) << 16
);
assert_eq!(fw_rev[1], DEFAULT_APP_VERSION);
}
#[test]
fn test_update() {
let image_options = ImageOptions {
fmc_version: DEFAULT_FMC_VERSION,
app_version: 0xaabbccdd,
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
// Make image to update to. On the FPGA this needs to be done before executing the test,
// otherwise the test will fail because processor is too busy building to be able to respond to
// the TRNG call during the initial boot.
let image =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options)
.unwrap()
.to_bytes()
.unwrap();
// Test that the normal runtime firmware boots.
// Ultimately, this will be useful for exercising Caliptra end-to-end
// via the mailbox.
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &image)
.unwrap();
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
let fw_rev = model.soc_ifc().cptra_fw_rev_id().read();
assert_eq!((fw_rev[0] >> 16) as u16, DEFAULT_FMC_VERSION);
assert_eq!(fw_rev[1], 0xaabbccdd);
}
///This test will be run for 500 times if feature "slow_tests" is enabled and just once if the feature is absent
#[test]
fn test_stress_update() {
let app_versions = [0xaaabbbbc, 0xaaabbbbd];
let image_options_0 = ImageOptions {
app_version: app_versions[0],
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let image_options_1 = ImageOptions {
app_version: app_versions[1],
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let image = [
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options_0)
.unwrap()
.to_bytes()
.unwrap(),
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options_1)
.unwrap()
.to_bytes()
.unwrap(),
];
let mut model = run_rt_test(RuntimeTestArgs::default());
let stress_num = if cfg!(feature = "slow_tests") { 250 } else { 1 };
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
let mut image_select = 0;
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
for _ in 0..stress_num {
if image_select == 0 {
image_select = 1;
} else {
image_select = 0;
};
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &image[image_select])
.unwrap();
model.step_until_boot_status(RT_READY_FOR_COMMANDS, true);
//Check if the new firmware is actually the one we built
let fw_rev = model.soc_ifc().cptra_fw_rev_id().read();
assert_eq!((fw_rev[0] >> 16) as u16, DEFAULT_FMC_VERSION);
assert_eq!(fw_rev[1], app_versions[image_select]);
}
}
#[test]
fn test_boot_tci_data() {
let args = RuntimeTestArgs {
test_fwid: Some(crate::test_update_reset::mbox_test_image()),
..Default::default()
};
let mut model = run_rt_test(args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let valid_pauser_hash_resp = model.mailbox_execute(0x2000_0000, &[]).unwrap().unwrap();
let valid_pauser_hash: [u8; 48] = valid_pauser_hash_resp.as_bytes().try_into().unwrap();
// hash expected DPE measurements in order
let mut hasher = Sha384::new();
hasher.update(rt_journey_pcr);
hasher.update(valid_pauser_hash);
let expected_measurement_hash = hasher.finalize();
let dpe_measurement_hash = model.mailbox_execute(0x3000_0000, &[]).unwrap().unwrap();
assert_eq!(expected_measurement_hash.as_bytes(), dpe_measurement_hash);
}
#[test]
fn test_measurement_in_measurement_log_added_to_dpe() {
for pqc_key_type in PQC_KEY_TYPE.iter() {
let image_options = ImageOptions {
pqc_key_type: *pqc_key_type,
..Default::default()
};
let fuses = Fuses {
fuse_pqc_key_type: *pqc_key_type as u32,
..Default::default()
};
let rom = crate::common::rom_for_fw_integration_tests().unwrap();
let life_cycle = fuses.life_cycle;
let mut model = caliptra_hw_model::new(
InitParams {
fuses,
rom: &rom,
security_state: SecurityState::from(life_cycle as u32),
ss_init_params: SubsystemInitParams {
enable_mcu_uart_log: cfg!(feature = "fpga_subsystem"),
..Default::default()
},
..Default::default()
},
BootParams {
..Default::default()
},
)
.unwrap();
let image_bundle = caliptra_builder::build_and_sign_image(
&FMC_WITH_UART,
crate::test_update_reset::mbox_test_image(),
image_options,
)
.unwrap();
// Upload measurement to measurement log
let measurement: [u8; 48] = [0xdeadbeef_u32; 12].as_bytes().try_into().unwrap();
let mut measurement_log_entry = MailboxReq::StashMeasurement(StashMeasurementReq {
measurement,
hdr: MailboxReqHeader { chksum: 0 },
metadata: [0xAB; 4],
context: [0xCD; 48],
svn: 0xEF01,
});
measurement_log_entry.populate_chksum().unwrap();
model
.upload_measurement(measurement_log_entry.as_bytes().unwrap())
.unwrap();
crate::common::test_upload_firmware(
&mut model,
&image_bundle.to_bytes().unwrap(),
*pqc_key_type,
);
model.step_until(|m| m.soc_ifc().cptra_flow_status().read().ready_for_runtime());
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let valid_pauser_hash_resp = model.mailbox_execute(0x2000_0000, &[]).unwrap().unwrap();
let valid_pauser_hash: [u8; 48] = valid_pauser_hash_resp.as_bytes().try_into().unwrap();
// hash expected DPE measurements in order
let mut hasher = Sha384::new();
hasher.update(rt_journey_pcr);
hasher.update(valid_pauser_hash);
hasher.update(measurement);
let expected_measurement_hash = hasher.finalize();
let dpe_measurement_hash = model.mailbox_execute(0x3000_0000, &[]).unwrap().unwrap();
assert_eq!(expected_measurement_hash.as_bytes(), dpe_measurement_hash);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_revoke_exported_cdi_handle.rs | runtime/tests/runtime_integration_tests/test_revoke_exported_cdi_handle.rs | // Licensed under the Apache-2.0 license
use caliptra_api::{mailbox::RevokeExportedCdiHandleReq, SocManager};
use caliptra_common::mailbox_api::{CommandId, MailboxReq, MailboxReqHeader};
use caliptra_error::CaliptraError;
use caliptra_hw_model::HwModel;
use caliptra_runtime::RtBootStatus;
use dpe::{
commands::{Command, DeriveContextCmd, DeriveContextFlags},
context::ContextHandle,
response::Response,
DPE_PROFILE,
};
use crate::common::{assert_error, execute_dpe_cmd, run_rt_test, DpeResult, RuntimeTestArgs};
#[test]
fn test_revoke_exported_cdi_handle() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(original_cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: original_cdi_resp.exported_cdi,
});
cmd.populate_chksum().unwrap();
model
.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
)
.expect("Expected REVOKE_EXPORTED_CDI_HANDLE to pass");
}
#[test]
fn test_revoke_already_revoked_exported_cdi_handle() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI | DeriveContextFlags::CREATE_CERTIFICATE,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(original_cdi_resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: original_cdi_resp.exported_cdi,
});
cmd.populate_chksum().unwrap();
model
.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
)
.expect("Expected REVOKE_EXPORTED_CDI_HANDLE to pass");
let result = model.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
);
assert_error(
&mut model,
CaliptraError::RUNTIME_REVOKE_EXPORTED_CDI_HANDLE_NOT_FOUND,
result.err().unwrap(),
);
}
#[test]
fn test_revoke_non_existant_exported_cdi_handle() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: [0xFF; RevokeExportedCdiHandleReq::EXPORTED_CDI_MAX_SIZE],
});
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
);
assert_error(
&mut model,
CaliptraError::RUNTIME_REVOKE_EXPORTED_CDI_HANDLE_NOT_FOUND,
result.err().unwrap(),
);
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq::default());
cmd.populate_chksum().unwrap();
let result = model.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
);
assert_error(
&mut model,
CaliptraError::RUNTIME_REVOKE_EXPORTED_CDI_HANDLE_NOT_FOUND,
result.err().unwrap(),
);
}
#[test]
fn test_export_cdi_after_revoke() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let export_cdi_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::EXPORT_CDI
| DeriveContextFlags::CREATE_CERTIFICATE
| DeriveContextFlags::RETAIN_PARENT_CONTEXT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
let Some(Response::DeriveContextExportedCdi(resp)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
let mut cmd = MailboxReq::RevokeExportedCdiHandle(RevokeExportedCdiHandleReq {
hdr: MailboxReqHeader { chksum: 0 },
exported_cdi_handle: resp.exported_cdi,
});
cmd.populate_chksum().unwrap();
model
.mailbox_execute(
CommandId::REVOKE_EXPORTED_CDI_HANDLE.into(),
cmd.as_bytes().unwrap(),
)
.expect("Expected REVOKE_EXPORTED_CDI_HANDLE to pass");
let Some(Response::DeriveContextExportedCdi(_)) = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&export_cdi_cmd),
DpeResult::Success,
) else {
panic!("expected derive context resp!")
};
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_update_reset.rs | runtime/tests/runtime_integration_tests/test_update_reset.rs | // Licensed under the Apache-2.0 license
use std::mem::size_of;
pub use caliptra_api::SocManager;
use caliptra_builder::{
firmware::{
runtime_tests::{MBOX, MBOX_FPGA, MBOX_WITHOUT_UART, MBOX_WITHOUT_UART_FPGA},
APP_WITH_UART, FMC_FAKE_WITH_UART, FMC_WITH_UART,
},
FwId, ImageOptions,
};
use caliptra_common::mailbox_api::{
CommandId, FwInfoResp, IncrementPcrResetCounterReq, MailboxReq, MailboxReqHeader, TagTciReq,
};
use caliptra_drivers::PcrResetCounter;
use caliptra_error::CaliptraError;
use caliptra_hw_model::{
DefaultHwModel, DeviceLifecycle, HwModel, InitParams, ModelError, SecurityState,
};
use caliptra_image_types::FwVerificationPqcKeyType;
use caliptra_runtime::{ContextState, RtBootStatus, PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD};
use dpe::{
context::{Context, ContextHandle, ContextType},
response::DpeErrorCode,
tci::TciMeasurement,
validation::ValidationError,
U8Bool, DPE_PROFILE, MAX_HANDLES,
};
use zerocopy::{FromBytes, IntoBytes, TryFromBytes};
use crate::common::{run_rt_test, RuntimeTestArgs};
pub fn update_fw(model: &mut DefaultHwModel, rt_fw: &FwId<'static>, image_opts: ImageOptions) {
let image = caliptra_builder::build_and_sign_image(&FMC_WITH_UART, rt_fw, image_opts)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &image)
.unwrap();
}
pub fn mbox_test_image() -> &'static FwId<'static> {
if cfg!(any(feature = "fpga_realtime", feature = "fpga_subsystem")) {
&MBOX_FPGA
} else {
&MBOX
}
}
#[test]
fn test_rt_journey_pcr_updated_in_dpe() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// trigger update reset
update_fw(&mut model, mbox_test_image(), image_options);
let rt_journey_pcr_resp = model.mailbox_execute(0x1000_0000, &[]).unwrap().unwrap();
let rt_journey_pcr: [u8; 48] = rt_journey_pcr_resp.as_bytes().try_into().unwrap();
let dpe_root_measurement_resp = model.mailbox_execute(0x6000_0000, &[]).unwrap().unwrap();
let dpe_root_measurement: [u8; 48] = dpe_root_measurement_resp.as_bytes().try_into().unwrap();
assert_eq!(dpe_root_measurement, rt_journey_pcr);
}
#[test]
fn test_tags_persistence() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Tag default context in order to change the context tags in persistent data
let mut cmd = MailboxReq::TagTci(TagTciReq {
hdr: MailboxReqHeader { chksum: 0 },
handle: [0u8; 16],
tag: 1,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(u32::from(CommandId::DPE_TAG_TCI), cmd.as_bytes().unwrap())
.unwrap()
.expect("We expected a response");
// trigger update reset
update_fw(&mut model, mbox_test_image(), image_options.clone());
const TAGS_INFO_SIZE: usize =
size_of::<u32>() * MAX_HANDLES + size_of::<U8Bool>() * MAX_HANDLES;
let tags_resp_1 = model.mailbox_execute(0x7000_0000, &[]).unwrap().unwrap();
let tags_1: [u8; TAGS_INFO_SIZE] = tags_resp_1.as_bytes().try_into().unwrap();
// trigger another update reset with same fw
update_fw(&mut model, mbox_test_image(), image_options);
let tags_resp_2 = model.mailbox_execute(0x7000_0000, &[]).unwrap().unwrap();
let tags_2: [u8; TAGS_INFO_SIZE] = tags_resp_2.as_bytes().try_into().unwrap();
// check that the tags are the same across update resets
assert_eq!(tags_1, tags_2);
// check that the tags are not default tags
assert_ne!(tags_1, [0u8; TAGS_INFO_SIZE]);
}
#[test]
fn test_context_tags_validation() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
// make context_tags validation fail by "tagging" an inactive context
let mut context_tags = [0u32; MAX_HANDLES];
context_tags[20] = 1;
let _ = model
.mailbox_execute(0x8000_0000, context_tags.as_bytes())
.unwrap()
.unwrap();
// trigger update reset
let fw_id = if cfg!(all(feature = "fpga_realtime", feature = "fpga_subsystem")) {
&MBOX_WITHOUT_UART
} else {
&MBOX_WITHOUT_UART_FPGA
};
update_fw(&mut model, fw_id, image_options);
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_CONTEXT_TAGS_VALIDATION_FAILED)
});
}
#[test]
fn test_context_has_tag_validation() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let args = RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(args);
// make context_has_tag validation fail by "tagging" an inactive context
let mut context_has_tag = [U8Bool::new(false); MAX_HANDLES];
context_has_tag[20] = U8Bool::new(true);
let _ = model
.mailbox_execute(0x9000_0000, context_has_tag.as_bytes())
.unwrap()
.unwrap();
// trigger update reset
update_fw(&mut model, &APP_WITH_UART, image_options);
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_CONTEXT_HAS_TAG_VALIDATION_FAILED)
});
}
#[test]
fn test_dpe_validation_deformed_structure() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let args = RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(args);
// read DPE after RT initialization
let dpe_resp = model.mailbox_execute(0xA000_0000, &[]).unwrap().unwrap();
let mut dpe = dpe::State::try_read_from_bytes(dpe_resp.as_bytes()).unwrap();
// corrupt DPE structure by creating multiple normal connected components
dpe.contexts[0].children = 0;
dpe.contexts[0].state = ContextState::Active;
dpe.contexts[1].parent_idx = Context::ROOT_INDEX;
let _ = model
.mailbox_execute(0xB000_0000, dpe.as_bytes())
.unwrap()
.unwrap();
// trigger update reset
update_fw(&mut model, &APP_WITH_UART, image_options);
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_DPE_VALIDATION_FAILED)
});
assert_eq!(
model
.soc_ifc()
.cptra_fw_extended_error_info()
.read()
.as_bytes()[..size_of::<u32>()],
DpeErrorCode::Validation(ValidationError::MultipleNormalConnectedComponents)
.get_error_code()
.to_le_bytes()
);
// check attestation disabled via FW_INFO
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(info.attestation_disabled, 1);
}
#[test]
fn test_dpe_validation_illegal_state() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let args = RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(args);
// read DPE after RT initialization
let dpe_resp = model.mailbox_execute(0xA000_0000, &[]).unwrap().unwrap();
let mut dpe = dpe::State::try_read_from_bytes(dpe_resp.as_bytes()).unwrap();
// corrupt DPE state by messing up parent-child links
dpe.contexts[1].children = 0b1;
let _ = model
.mailbox_execute(0xB000_0000, dpe.as_bytes())
.unwrap()
.unwrap();
// trigger update reset
update_fw(&mut model, &APP_WITH_UART, image_options);
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_DPE_VALIDATION_FAILED)
});
assert_eq!(
model
.soc_ifc()
.cptra_fw_extended_error_info()
.read()
.as_bytes()[..size_of::<u32>()],
DpeErrorCode::Validation(ValidationError::ParentChildLinksCorrupted)
.get_error_code()
.to_le_bytes()
);
// check attestation disabled via FW_INFO
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(info.attestation_disabled, 1);
}
#[test]
fn test_dpe_validation_used_context_threshold_exceeded() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let args = RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(args);
// read DPE after RT initialization
let dpe_resp = model.mailbox_execute(0xA000_0000, &[]).unwrap().unwrap();
let mut dpe = dpe::State::try_read_from_bytes(dpe_resp.as_bytes()).unwrap();
// corrupt DPE structure by creating PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD contexts
let pl0_pauser = ImageOptions::default().vendor_config.pl0_pauser.unwrap();
// make dpe.contexts[1].handle non-default in order to pass dpe state validation
dpe.contexts[1].handle = ContextHandle([1u8; ContextHandle::SIZE]);
// the mbox valid pausers measurement and RT journey measurement already count as PL0
// so creating PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD suffices
for i in 0..(PL0_DPE_ACTIVE_CONTEXT_DEFAULT_THRESHOLD - 1) {
// skip first two contexts measured by RT
let idx = i + 2;
// create simulation contexts in PL0
dpe.contexts[idx].state = ContextState::Active;
dpe.contexts[idx].context_type = ContextType::Simulation;
dpe.contexts[idx].locality = pl0_pauser;
dpe.contexts[idx].tci.locality = pl0_pauser;
dpe.contexts[idx].tci.tci_current = TciMeasurement([idx as u8; DPE_PROFILE.tci_size()]);
dpe.contexts[idx].tci.tci_cumulative = TciMeasurement([idx as u8; DPE_PROFILE.tci_size()]);
dpe.contexts[idx].handle = ContextHandle([idx as u8; ContextHandle::SIZE]);
}
let _ = model
.mailbox_execute(0xB000_0000, dpe.as_bytes())
.unwrap()
.unwrap();
// trigger update reset
update_fw(&mut model, &APP_WITH_UART, image_options);
model.step_until(|m| {
m.soc_ifc().cptra_fw_error_non_fatal().read()
== u32::from(CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_EXCEEDED)
});
// check attestation disabled via FW_INFO
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::FW_INFO), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::FW_INFO), payload.as_bytes())
.unwrap()
.unwrap();
let info = FwInfoResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(info.attestation_disabled, 1);
}
#[test]
fn test_pcr_reset_counter_persistence() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_args = RuntimeTestArgs {
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_args);
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
// Increment counter for PCR0 in order to change the pcr reset counter in persistent data
let mut cmd = MailboxReq::IncrementPcrResetCounter(IncrementPcrResetCounterReq {
hdr: MailboxReqHeader { chksum: 0 },
index: 0,
});
cmd.populate_chksum().unwrap();
let _ = model
.mailbox_execute(
u32::from(CommandId::INCREMENT_PCR_RESET_COUNTER),
cmd.as_bytes().unwrap(),
)
.unwrap()
.expect("We expected a response");
// trigger update reset
update_fw(&mut model, mbox_test_image(), image_options.clone());
let pcr_reset_counter_resp_1 = model.mailbox_execute(0xC000_0000, &[]).unwrap().unwrap();
let pcr_reset_counter_1: [u8; size_of::<PcrResetCounter>()] =
pcr_reset_counter_resp_1.as_bytes().try_into().unwrap();
// trigger another update reset with same fw
update_fw(&mut model, mbox_test_image(), image_options);
let pcr_reset_counter_resp_2 = model.mailbox_execute(0xC000_0000, &[]).unwrap().unwrap();
let pcr_reset_counter_2: [u8; size_of::<PcrResetCounter>()] =
pcr_reset_counter_resp_2.as_bytes().try_into().unwrap();
// check that the pcr reset counters are the same across update resets
assert_eq!(pcr_reset_counter_1, pcr_reset_counter_2);
// check that the pcr reset counters are not default
assert_ne!(pcr_reset_counter_1, [0u8; size_of::<PcrResetCounter>()]);
}
fn get_image_opts(svn: u32) -> ImageOptions {
ImageOptions {
fw_svn: svn,
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
}
}
fn cold_update_to_svn(model: DefaultHwModel, svn: u32) -> DefaultHwModel {
drop(model);
run_rt_test(RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(get_image_opts(svn)),
..Default::default()
})
}
fn runtime_update_to_svn(model: &mut DefaultHwModel, svn: u32) {
update_fw(model, mbox_test_image(), get_image_opts(svn));
}
fn get_ladder_digest(model: &mut DefaultHwModel, target_svn: u32) -> Vec<u8> {
let digest = model
.mailbox_execute(0x1000_1000, target_svn.as_bytes())
.unwrap()
.unwrap();
assert!(!digest.is_empty());
digest
}
fn assert_target_svn_too_large(model: &mut DefaultHwModel, target_svn: u32) {
assert_eq!(
model.mailbox_execute(0x1000_1000, target_svn.as_bytes()),
Err(ModelError::MailboxCmdFailed(u32::from(
CaliptraError::RUNTIME_KEY_LADDER_TARGET_SVN_TOO_LARGE,
)))
);
}
const MAX_SVN: u32 = 128;
#[test]
fn test_key_ladder_cold_boot() {
let mut model = run_rt_test(RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(get_image_opts(0)),
..Default::default()
});
let ladder_0 = get_ladder_digest(&mut model, 0);
model = cold_update_to_svn(model, 1);
// FW should now have a different key ladder.
let ladder_1 = get_ladder_digest(&mut model, 1);
// Ask FW to extend the ladder once before returning a digest.
let ladder_0_from_1 = get_ladder_digest(&mut model, 0);
assert_ne!(ladder_0_from_1, ladder_1);
assert_eq!(ladder_0_from_1, ladder_0);
// Update to the max SVN supported by ROM.
model = cold_update_to_svn(model, MAX_SVN);
let ladder_max = get_ladder_digest(&mut model, MAX_SVN);
// Ask FW for a secret available to SVN 1.
let ladder_1_from_max = get_ladder_digest(&mut model, 1);
assert_ne!(ladder_1_from_max, ladder_max);
assert_eq!(ladder_1_from_max, ladder_1);
}
#[test]
fn test_key_ladder_runtime_update() {
let mut model = run_rt_test(RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
test_image_options: Some(get_image_opts(5)),
..Default::default()
});
// Start at SVN 5. (Min-SVN = 5)
let ladder_5 = get_ladder_digest(&mut model, 5);
// Update to SVN 6. (Min-SVN = 5)
runtime_update_to_svn(&mut model, 6);
let ladder_6 = get_ladder_digest(&mut model, 5);
assert_eq!(ladder_5, ladder_6);
// Try to get a secret for SVN 6 while the min-SVN is still 5.
assert_target_svn_too_large(&mut model, 6);
// Downgrade to SVN 4. (Min-SVN = 4)
runtime_update_to_svn(&mut model, 4);
let ladder_4 = get_ladder_digest(&mut model, 4);
assert_ne!(ladder_4, ladder_5);
assert_target_svn_too_large(&mut model, 5);
// Upgrade to SVN 5. (Min-SVN = 4)
runtime_update_to_svn(&mut model, 5);
let ladder_5_after_4 = get_ladder_digest(&mut model, 4);
assert_eq!(ladder_5_after_4, ladder_4);
assert_target_svn_too_large(&mut model, 5);
// Upgrade to SVN 6. (Min-SVN = 4)
runtime_update_to_svn(&mut model, 6);
let ladder_6_after_4 = get_ladder_digest(&mut model, 4);
assert_eq!(ladder_6_after_4, ladder_4);
assert_target_svn_too_large(&mut model, 5);
assert_target_svn_too_large(&mut model, 6);
// Cold-boot to SVN 6 (Min-SVN = 6)
model = cold_update_to_svn(model, 6);
let ladder_6_after_boot = get_ladder_digest(&mut model, 6);
assert_ne!(ladder_6_after_boot, ladder_6_after_4);
let ladder_5_from_6 = get_ladder_digest(&mut model, 5);
let ladder_4_from_6 = get_ladder_digest(&mut model, 4);
assert_eq!(ladder_5_from_6, ladder_5);
assert_eq!(ladder_4_from_6, ladder_4);
// Can still get its own secret after deriving older ones.
let ladder_6_from_self = get_ladder_digest(&mut model, 6);
assert_eq!(ladder_6_from_self, ladder_6_after_boot);
assert_target_svn_too_large(&mut model, 7);
// Downgrade to SVN 5 (Min-SVN = 5)
runtime_update_to_svn(&mut model, 5);
let ladder_5_after_boot = get_ladder_digest(&mut model, 5);
assert_eq!(ladder_5_after_boot, ladder_5);
let ladder_4_from_5 = get_ladder_digest(&mut model, 4);
assert_eq!(ladder_4_from_5, ladder_4);
assert_target_svn_too_large(&mut model, 6);
}
#[test]
fn test_key_ladder_max_svn() {
let mut model = run_rt_test(RuntimeTestArgs {
test_fwid: Some(mbox_test_image()),
..Default::default()
});
let resp = model.mailbox_execute(0xF000_0000, &[]).unwrap().unwrap();
let max = u16::from_le_bytes(resp.try_into().unwrap());
assert_eq!(max as u32, MAX_SVN);
}
fn make_model_with_security_state(
fmc: &'static FwId<'static>,
app: &'static FwId<'static>,
debug_locked: bool,
lifecycle: DeviceLifecycle,
) -> DefaultHwModel {
run_rt_test(RuntimeTestArgs {
test_fwid: Some(app),
test_fmc_fwid: Some(fmc),
init_params: Some(InitParams {
rom: &crate::common::rom_for_fw_integration_tests().unwrap(),
security_state: *SecurityState::default()
.set_debug_locked(debug_locked)
.set_device_lifecycle(lifecycle),
..Default::default()
}),
..Default::default()
})
}
#[test]
// With FPGA subsystem setting the device lifecycle automatically sets a value of debug_unlock
#[cfg_attr(feature = "fpga_subsystem", ignore)]
fn test_key_ladder_changes_with_lifecycle() {
// Test with several combinations of security state.
let ladder_a = {
let mut model = make_model_with_security_state(
&FMC_WITH_UART,
mbox_test_image(),
false,
DeviceLifecycle::Production,
);
get_ladder_digest(&mut model, 0)
};
let ladder_b = {
let mut model = make_model_with_security_state(
&FMC_WITH_UART,
mbox_test_image(),
false,
DeviceLifecycle::Manufacturing,
);
get_ladder_digest(&mut model, 0)
};
let ladder_c = {
let mut model = make_model_with_security_state(
&FMC_WITH_UART,
mbox_test_image(),
true,
DeviceLifecycle::Production,
);
get_ladder_digest(&mut model, 0)
};
let ladder_d = {
let mut model = make_model_with_security_state(
&FMC_WITH_UART,
mbox_test_image(),
true,
DeviceLifecycle::Manufacturing,
);
get_ladder_digest(&mut model, 0)
};
assert_ne!(ladder_a, ladder_b);
assert_ne!(ladder_a, ladder_c);
assert_ne!(ladder_a, ladder_d);
assert_ne!(ladder_b, ladder_c);
assert_ne!(ladder_b, ladder_d);
assert_ne!(ladder_c, ladder_d);
}
#[test]
fn test_key_ladder_stable_across_fw_updates() {
// Update both FMC and app FW, and ensure the key ladder is still identical.
let (fmc_a, app_a) = (&FMC_WITH_UART, mbox_test_image());
let (fmc_b, app_b) = (
&FMC_FAKE_WITH_UART,
if cfg!(feature = "fpga_subsystem") {
&MBOX_WITHOUT_UART_FPGA
} else {
&MBOX_WITHOUT_UART
},
);
let ladder_a = {
let mut model =
make_model_with_security_state(fmc_a, app_a, true, DeviceLifecycle::Production);
get_ladder_digest(&mut model, 0)
};
let ladder_b = {
let mut model =
make_model_with_security_state(fmc_b, app_b, true, DeviceLifecycle::Production);
get_ladder_digest(&mut model, 0)
};
assert_eq!(ladder_a, ladder_b);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_reallocate_dpe_context_limits.rs | runtime/tests/runtime_integration_tests/test_reallocate_dpe_context_limits.rs | // Licensed under the Apache-2.0 license.
use crate::common::{execute_dpe_cmd, run_rt_test, DpeResult, RuntimeTestArgs};
use caliptra_api::mailbox::{
CommandId, ReallocateDpeContextLimitsReq, ReallocateDpeContextLimitsResp,
};
use caliptra_builder::{
firmware::{APP_WITH_UART, FMC_WITH_UART},
ImageOptions,
};
use caliptra_common::mailbox_api::{MailboxReq, MailboxReqHeader};
use caliptra_drivers::CaliptraError;
use caliptra_hw_model::{DefaultHwModel, HwModel, ModelError};
use caliptra_image_types::FwVerificationPqcKeyType;
use dpe::{
commands::{Command, DeriveContextCmd, DeriveContextFlags},
context::ContextHandle,
DPE_PROFILE,
};
use zerocopy::FromBytes;
fn fill_max_dpe_contexts(model: &mut DefaultHwModel, pl0_limit: u32, pl1_limit: u32) {
const BASE_DERIVE_CONTEXT_CMD: DeriveContextCmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::MAKE_DEFAULT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// 32 contexts = 1 root node (PL0)+
// 1 rt_journey (PL0)
// (pl0_limit - 2) PL0 contexts in loop +
// 1 PL1 context as transition +
// (pl1_limit - 1) PL1 contexts in loop
// Fill PL0 contexts
println!("Filling PL0 contexts up to limit {}", pl0_limit);
for _ in 0..(pl0_limit - 2) {
let _ = execute_dpe_cmd(
model,
&mut Command::DeriveContext(&BASE_DERIVE_CONTEXT_CMD),
DpeResult::Success,
);
}
println!("triggering PL0 failure");
// Trigger failure by trying to derive one more context to PL0
let _ = execute_dpe_cmd(
model,
&mut Command::DeriveContext(&BASE_DERIVE_CONTEXT_CMD),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED),
);
println!("Filling PL1 contexts up to limit {}", pl1_limit);
// Fill PL1 contexts
for i in 0..pl1_limit {
if i == 0 {
// Transition to PL1 locality on first iteration
let derive_ctx_cmd = DeriveContextCmd {
flags: DeriveContextFlags::MAKE_DEFAULT | DeriveContextFlags::CHANGE_LOCALITY,
target_locality: 2,
..BASE_DERIVE_CONTEXT_CMD
};
let _ = execute_dpe_cmd(
model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
model.set_axi_user(2);
} else {
let _ = execute_dpe_cmd(
model,
&mut Command::DeriveContext(&BASE_DERIVE_CONTEXT_CMD),
DpeResult::Success,
);
}
}
println!("triggering PL1 failure");
// Trigger failure by trying to derive one more context to PL1
let _ = execute_dpe_cmd(
model,
&mut Command::DeriveContext(&BASE_DERIVE_CONTEXT_CMD),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_PL1_USED_DPE_CONTEXT_THRESHOLD_REACHED),
);
}
fn reallocate_pl0_pl1_dpe_contexts(
model: &mut DefaultHwModel,
pl0_limit: u32,
) -> Result<Option<Vec<u8>>, ModelError> {
let mut cmd = MailboxReq::ReallocateDpeContextLimits(ReallocateDpeContextLimitsReq {
hdr: MailboxReqHeader { chksum: 0 },
pl0_context_limit: pl0_limit,
});
cmd.populate_chksum().unwrap();
model.mailbox_execute(
u32::from(CommandId::REALLOCATE_DPE_CONTEXT_LIMITS),
cmd.as_bytes().unwrap(),
)
}
#[test]
fn test_pl0_pl1_reallocation_range() {
for pl0_limit in 2..dpe::MAX_HANDLES as u32 {
println!("\n\n\tPL0 Limit {}\n\n", pl0_limit);
let mut model = run_rt_test(RuntimeTestArgs::default());
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, pl0_limit)
.unwrap()
.expect("We should have received a response");
let reallocate_resp =
ReallocateDpeContextLimitsResp::read_from_bytes(resp.as_slice()).unwrap();
assert_eq!(reallocate_resp.new_pl0_context_limit, pl0_limit);
assert_eq!(reallocate_resp.new_pl1_context_limit, 32 - pl0_limit);
fill_max_dpe_contexts(&mut model, pl0_limit, 32 - pl0_limit);
}
}
#[test]
fn test_pl0_pl1_reallocation_call_outside_pl0() {
let mut model = run_rt_test(RuntimeTestArgs::default());
// Set Non-PL0 PAUSER
model.set_axi_user(2);
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, 20).unwrap_err();
assert_eq!(
resp,
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_INCORRECT_PAUSER_PRIVILEGE_LEVEL.into()
)
);
}
#[test]
fn test_pl0_pl1_reallocation_pl0_less_than_min() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, 1).unwrap_err();
assert_eq!(
resp,
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_REALLOCATE_DPE_CONTEXTS_PL0_LESS_THAN_MIN.into()
)
);
}
#[test]
fn test_pl0_pl1_reallocation_pl0_greater_than_max() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, 33).unwrap_err();
assert_eq!(
resp,
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_REALLOCATE_DPE_CONTEXTS_PL0_GREATER_THAN_MAX.into()
)
);
}
#[test]
fn test_pl0_pl1_reallocation_pl0_less_than_used() {
let mut model = run_rt_test(RuntimeTestArgs::default());
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::MAKE_DEFAULT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// Use some PL0 contexts
for _ in 0..12 {
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
}
// Try to reallocate contexts to limit PL0 to 8
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, 8).unwrap_err();
assert_eq!(
resp,
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_REALLOCATE_DPE_CONTEXTS_PL0_LESS_THAN_USED.into()
)
);
}
#[test]
fn test_pl0_pl1_reallocation_pl1_less_than_used() {
let mut model = run_rt_test(RuntimeTestArgs::default());
const BASE_DERIVE_CONTEXT_CMD: DeriveContextCmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::MAKE_DEFAULT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// Use some PL1 contexts
for i in 0..12 {
if i == 0 {
// Transition to PL1 locality on first iteration
let derive_ctx_cmd = DeriveContextCmd {
flags: DeriveContextFlags::MAKE_DEFAULT | DeriveContextFlags::CHANGE_LOCALITY,
target_locality: 2,
..BASE_DERIVE_CONTEXT_CMD
};
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_ctx_cmd),
DpeResult::Success,
);
model.set_axi_user(2);
} else {
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&BASE_DERIVE_CONTEXT_CMD),
DpeResult::Success,
);
}
}
// Call from PL0
model.set_axi_user(1);
// Try to reallocate contexts to limit PL0 to 24
let resp = reallocate_pl0_pl1_dpe_contexts(&mut model, 24).unwrap_err();
assert_eq!(
resp,
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_REALLOCATE_DPE_CONTEXTS_PL1_LESS_THAN_USED.into()
)
);
}
#[test]
fn test_pl0_pl1_reallocation_warm_reset() {
let image_options = ImageOptions {
pqc_key_type: FwVerificationPqcKeyType::LMS,
..Default::default()
};
let runtime_test_args = RuntimeTestArgs {
test_image_options: Some(image_options.clone()),
..Default::default()
};
let mut model = run_rt_test(runtime_test_args);
let derive_context_cmd = DeriveContextCmd {
handle: ContextHandle::default(),
data: [0; DPE_PROFILE.tci_size()],
flags: DeriveContextFlags::MAKE_DEFAULT,
tci_type: 0,
target_locality: 0,
svn: 0,
};
// Use some PL0 contexts
for _ in 0..12 {
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
}
// Increase PL0 context limit
reallocate_pl0_pl1_dpe_contexts(&mut model, 24)
.unwrap()
.expect("We should have received a response");
// Trigger update reset to same firmware
let image =
caliptra_builder::build_and_sign_image(&FMC_WITH_UART, &APP_WITH_UART, image_options)
.unwrap()
.to_bytes()
.unwrap();
model
.mailbox_execute(u32::from(CommandId::FIRMWARE_LOAD), &image)
.unwrap();
// Use the rest of the PL0 contexts
// (2 contexts are used by Caliptra)
for _ in 0..10 {
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::Success,
);
}
// Trigger failure by trying to derive one more context to PL0
let _ = execute_dpe_cmd(
&mut model,
&mut Command::DeriveContext(&derive_context_cmd),
DpeResult::MboxCmdFailure(CaliptraError::RUNTIME_PL0_USED_DPE_CONTEXT_THRESHOLD_REACHED),
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_mailbox.rs | runtime/tests/runtime_integration_tests/test_mailbox.rs | // Licensed under the Apache-2.0 license
use caliptra_api::SocManager;
use caliptra_common::mailbox_api::{CommandId, MailboxReqHeader};
use caliptra_hw_model::HwModel;
use zerocopy::IntoBytes;
use crate::common::{assert_error, run_rt_test, RuntimeTestArgs};
/// When a successful command runs after a failed command, ensure the error
/// register is cleared.
#[test]
fn test_error_cleared() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
// Send invalid command to cause failure
let resp = model.mailbox_execute(0xffffffff, &[]).unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_MAILBOX_INVALID_PARAMS,
resp,
);
// Succeed a command to make sure error gets cleared
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::VERSION), &[]),
};
let _ = model
.mailbox_execute(u32::from(CommandId::VERSION), payload.as_bytes())
.unwrap()
.unwrap();
assert_eq!(model.soc_ifc().cptra_fw_error_non_fatal().read(), 0);
}
#[test]
fn test_unimplemented_cmds() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
// Send something that is not a valid RT command.
const INVALID_CMD: u32 = 0xAABBCCDD;
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(INVALID_CMD, &[]),
};
let resp = model
.mailbox_execute(INVALID_CMD, payload.as_bytes())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_UNIMPLEMENTED_COMMAND,
resp,
);
}
#[test]
// Changing PAUSER not supported on sw emulator
#[cfg(any(
feature = "verilator",
feature = "fpga_realtime",
feature = "fpga_subsystem"
))]
fn test_reserved_pauser() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| m.soc_mbox().status().read().mbox_fsm_ps().mbox_idle());
// Set pauser to the reserved value
model.set_axi_user(0xffffffff);
// Send anything
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::VERSION), &[]),
};
let resp = model
.mailbox_execute(u32::from(CommandId::VERSION), payload.as_bytes())
.unwrap_err();
assert_error(
&mut model,
caliptra_drivers::CaliptraError::RUNTIME_CMD_RESERVED_PAUSER,
resp,
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_ocp_lock/test_derive_mek.rs | runtime/tests/runtime_integration_tests/test_ocp_lock/test_derive_mek.rs | // Licensed under the Apache-2.0 license
use std::sync::LazyLock;
use caliptra_api::mailbox::{
CommandId, MailboxReq, MailboxReqHeader, OcpLockDeriveMekReq, OcpLockDeriveMekResp,
OcpLockInitializeMekSecretReq,
};
use caliptra_error::CaliptraError;
use caliptra_hw_model::{HwModel, ModelError, SecurityState};
use caliptra_test::derive::{DoeInput, DoeOutput, Mek, OcpLockKeyLadderBuilder};
use crate::test_ocp_lock::InitializeMekSecretParams;
use super::{boot_ocp_lock_runtime, validate_ocp_lock_response, OcpLockBootParams};
use zerocopy::{FromBytes, IntoBytes};
static EXPECTED_MEK: LazyLock<Mek> = LazyLock::new(|| {
// Match the input params for the OCP LOCK Key ladder
// * Same UDS / FE
// * Same HEK
// * Same DPK / SEK
//
// This should create the same MEK that Caliptra does.
let doe_out = DoeOutput::generate(&DoeInput::default());
OcpLockKeyLadderBuilder::new(doe_out)
.add_mdk()
.add_hek([0xABDEu32; 8])
.add_intermediate_mek_secret([0xAB; 32], [0xCD; 32])
.derive_mek()
});
// TODO(clundin): Follow up with the following test cases:
//
// * MEK and MEK checksum are the same after a hitless update to new firmware.
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_mek() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xAB; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: EXPECTED_MEK.checksum,
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_eq!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_eq!(actual_mek.mek, EXPECTED_MEK.mek);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
/// Verifies MEK does not change after a warm reset.
fn test_derive_mek_warm_reset() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xAB; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
let mut derive_mek_cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: EXPECTED_MEK.checksum,
..Default::default()
});
derive_mek_cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
derive_mek_cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_eq!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_eq!(actual_mek.mek, EXPECTED_MEK.mek);
});
model.warm_reset_flow().unwrap();
let mut cmd = MailboxReq::OcpLockInitializeMekSecret(OcpLockInitializeMekSecretReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
sek: [0xAB; 32],
dpk: [0xCD; 32],
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_INITIALIZE_MEK_SECRET.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
response.unwrap().unwrap();
});
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
derive_mek_cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_eq!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_eq!(actual_mek.mek, EXPECTED_MEK.mek);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_mek_warm_reset_wipes_intermediate_secret() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xAB; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
model.warm_reset_flow().unwrap();
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: EXPECTED_MEK.checksum,
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_OCP_LOCK_MEK_NOT_INITIALIZED.into(),
)
);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_mek_debug_unlocked() {
let debug_unlocked_doe_out = DoeOutput::generate(&DoeInput::debug_unlocked());
let expected_debug_unlocked_mek = OcpLockKeyLadderBuilder::new(debug_unlocked_doe_out)
.add_mdk()
.add_hek([0xABDEu32; 8])
.add_intermediate_mek_secret([0xAB; 32], [0xCD; 32])
.derive_mek();
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xAB; 32],
dpk: [0xCD; 32],
}),
security_state: Some(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Unprovisioned)
.set_debug_locked(false),
),
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: expected_debug_unlocked_mek.checksum,
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_eq!(response.mek_checksum, expected_debug_unlocked_mek.checksum);
assert_eq!(actual_mek.mek, expected_debug_unlocked_mek.mek);
// Debug unlocked should not match the production UDS & FE.
assert_ne!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_ne!(actual_mek.mek, EXPECTED_MEK.mek);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_corrupted_sek() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xBE; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: EXPECTED_MEK.checksum,
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(CaliptraError::RUNTIME_OCP_LOCK_MEK_CHKSUM_FAIL.into(),)
);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_corrupted_sek_no_checksum() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xBE; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_ne!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_ne!(actual_mek.mek, EXPECTED_MEK.mek);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_missing_secret_seed() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: [0; 16],
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_OCP_LOCK_MEK_NOT_INITIALIZED.into(),
)
);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_consumed_secret_seed() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
init_mek_secret_params: Some(InitializeMekSecretParams {
sek: [0xAB; 32],
dpk: [0xCD; 32],
}),
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: [0; 16],
..Default::default()
});
cmd.populate_chksum().unwrap();
// Consumes the `MEK_SECRET_SEED` so `DERIVE_MEK` will not work until another call to `INITIALIZE_MEK_SECRET`
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, actual_mek| {
let response = response.unwrap().unwrap();
let response = OcpLockDeriveMekResp::ref_from_bytes(response.as_bytes()).unwrap();
assert_eq!(response.mek_checksum, EXPECTED_MEK.checksum);
assert_eq!(actual_mek.mek, EXPECTED_MEK.mek);
});
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_OCP_LOCK_MEK_NOT_INITIALIZED.into(),
)
);
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_derive_mek_missing_hek() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: false,
force_ocp_lock_en: true,
..Default::default()
});
let mut cmd = MailboxReq::OcpLockDeriveMek(OcpLockDeriveMekReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
mek_checksum: [0; 16],
..Default::default()
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_DERIVE_MEK.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_OCP_LOCK_MEK_NOT_INITIALIZED.into(),
)
);
});
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_ocp_lock/mod.rs | runtime/tests/runtime_integration_tests/test_ocp_lock/mod.rs | // Licensed under the Apache-2.0 license
use caliptra_api::{
mailbox::{
CapabilitiesResp, CommandId, MailboxReq, MailboxReqHeader, MailboxRespHeader,
OcpLockInitializeMekSecretReq, OcpLockReportHekMetadataReq, OcpLockReportHekMetadataResp,
OcpLockReportHekMetadataRespFlags,
},
Capabilities,
};
use caliptra_builder::{firmware::runtime_tests, FwId};
use caliptra_drivers::HekSeedState;
use caliptra_error::CaliptraError;
use caliptra_hw_model::{
DefaultHwModel, HwModel, ModelCallback, ModelError, OcpLockState, SecurityState,
};
use caliptra_image_types::FwVerificationPqcKeyType;
use dpe::U8Bool;
use zerocopy::{FromBytes, IntoBytes};
use crate::common::{run_rt_test, RuntimeTestArgs};
mod test_derive_mek;
mod test_get_algorithms;
mod test_initialize_mek_secret;
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_hek_metadata_never_reported() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
// This test assumes OCP LOCK is always enabled.
force_ocp_lock_en: true,
rt_fw_id: Some(&runtime_tests::MBOX_FPGA),
..Default::default()
});
// HEK can NEVER be valid if MCU ROM never reported the HEK metadata.
let expected_val = U8Bool::new(false);
let resp = model.mailbox_execute(0xF100_0000, &[]).unwrap().unwrap();
assert_eq!(resp.as_bytes(), expected_val.as_bytes());
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_hek_available() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
rt_fw_id: Some(&runtime_tests::MBOX_FPGA),
..Default::default()
});
// We reported HEK metadata so it should be available.
let expected_val = U8Bool::new(true);
let resp = model.mailbox_execute(0xF100_0000, &[]).unwrap().unwrap();
assert_eq!(resp.as_bytes(), expected_val.as_bytes());
}
struct InitializeMekSecretParams {
sek: [u8; 32],
dpk: [u8; 32],
}
#[derive(Default)]
struct OcpLockBootParams {
hek_available: bool,
init_mek_secret_params: Option<InitializeMekSecretParams>,
force_ocp_lock_en: bool,
rt_fw_id: Option<&'static FwId<'static>>,
security_state: Option<SecurityState>,
// The linter doesn't like using Default when all params are set.
_private: (),
}
fn boot_ocp_lock_runtime(params: OcpLockBootParams) -> DefaultHwModel {
let mut cmd = MailboxReq::OcpLockReportHekMetadata(OcpLockReportHekMetadataReq {
hdr: MailboxReqHeader { chksum: 0 },
seed_state: HekSeedState::Programmed.into(),
..Default::default()
});
cmd.populate_chksum().unwrap();
// A common operation is to report the HEK metadata.
// The HEK is not available without this step.
let cb = move |model: &mut DefaultHwModel| {
let response = model
.mailbox_execute(
CommandId::OCP_LOCK_REPORT_HEK_METADATA.into(),
cmd.as_bytes().unwrap(),
)
.unwrap()
.unwrap();
let response = OcpLockReportHekMetadataResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(response
.flags
.contains(OcpLockReportHekMetadataRespFlags::HEK_AVAILABLE));
};
let rom_callback: Option<ModelCallback> = if params.hek_available {
Some(Box::new(cb))
} else {
None
};
let security_state = params.security_state.unwrap_or(
*SecurityState::default()
.set_device_lifecycle(caliptra_hw_model::DeviceLifecycle::Production)
.set_debug_locked(true),
);
let mut model = run_rt_test(RuntimeTestArgs {
test_fwid: params.rt_fw_id,
ocp_lock_en: params.force_ocp_lock_en,
key_type: Some(FwVerificationPqcKeyType::MLDSA),
rom_callback,
security_state: Some(security_state),
..Default::default()
});
// Another common operation is to seed the MEK secret.
// Many commands, e.g. `DERIVE_MEK` will not work until this happens.
if let Some(params) = params.init_mek_secret_params {
// Initialize MEK Secret Seed
let mut cmd = MailboxReq::OcpLockInitializeMekSecret(OcpLockInitializeMekSecretReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
sek: params.sek,
dpk: params.dpk,
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_INITIALIZE_MEK_SECRET.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
response.unwrap().unwrap();
});
}
model
}
fn ocp_lock_supported(model: &mut DefaultHwModel) -> bool {
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(u32::from(CommandId::CAPABILITIES), &[]),
};
let response = model
.mailbox_execute(u32::from(CommandId::CAPABILITIES), payload.as_bytes())
.unwrap()
.unwrap();
let capabilities_resp = CapabilitiesResp::ref_from_bytes(response.as_bytes()).unwrap();
assert!(caliptra_common::checksum::verify_checksum(
capabilities_resp.hdr.chksum,
0x0,
&capabilities_resp.as_bytes()[core::mem::size_of_val(&capabilities_resp.hdr.chksum)..],
));
assert_eq!(
capabilities_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
let caps = Capabilities::try_from(capabilities_resp.capabilities.as_bytes()).unwrap();
assert!(caps.contains(Capabilities::RT_BASE));
caps.contains(Capabilities::RT_OCP_LOCK)
}
fn validate_ocp_lock_response(
model: &mut DefaultHwModel,
response: std::result::Result<Option<Vec<u8>>, ModelError>,
check_callback: impl FnOnce(std::result::Result<Option<Vec<u8>>, ModelError>, OcpLockState),
) {
if ocp_lock_supported(model) {
let state = model.ocp_lock_state().unwrap();
check_callback(response, state);
} else {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(
CaliptraError::RUNTIME_OCP_LOCK_UNSUPPORTED_COMMAND.into(),
)
);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_ocp_lock/test_get_algorithms.rs | runtime/tests/runtime_integration_tests/test_ocp_lock/test_get_algorithms.rs | // Licensed under the Apache-2.0 license
use caliptra_api::mailbox::{
AccessKeySizes, CommandId, EndorsementAlgorithms, HpkeAlgorithms, MailboxReqHeader,
MailboxRespHeader, OcpLockGetAlgorithmsResp,
};
use caliptra_api::SocManager;
use caliptra_hw_model::HwModel;
use caliptra_runtime::RtBootStatus;
use crate::common::{run_rt_test, RuntimeTestArgs};
use zerocopy::{FromBytes, IntoBytes};
use super::validate_ocp_lock_response;
#[test]
fn test_get_algorithms() {
let mut model = run_rt_test(RuntimeTestArgs::default());
model.step_until(|m| {
m.soc_ifc().cptra_boot_status().read() == u32::from(RtBootStatus::RtReadyForCommands)
});
let payload = MailboxReqHeader {
chksum: caliptra_common::checksum::calc_checksum(
u32::from(CommandId::OCP_LOCK_GET_ALGORITHMS),
&[],
),
};
let response = model.mailbox_execute(
u32::from(CommandId::OCP_LOCK_GET_ALGORITHMS),
payload.as_bytes(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
let response = response.unwrap().unwrap();
let get_algs_resp = OcpLockGetAlgorithmsResp::ref_from_bytes(response.as_bytes()).unwrap();
// Verify response checksum
assert!(caliptra_common::checksum::verify_checksum(
get_algs_resp.hdr.chksum,
0x0,
&get_algs_resp.as_bytes()[core::mem::size_of_val(&get_algs_resp.hdr.chksum)..],
));
// Verify FIPS status
assert_eq!(
get_algs_resp.hdr.fips_status,
MailboxRespHeader::FIPS_STATUS_APPROVED
);
assert_eq!(
get_algs_resp.endorsement_algorithms,
EndorsementAlgorithms::all()
);
assert_eq!(get_algs_resp.hpke_algorithms, HpkeAlgorithms::all());
assert_eq!(get_algs_resp.access_key_sizes, AccessKeySizes::LEN_256);
});
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/tests/runtime_integration_tests/test_ocp_lock/test_initialize_mek_secret.rs | runtime/tests/runtime_integration_tests/test_ocp_lock/test_initialize_mek_secret.rs | // Licensed under the Apache-2.0 license
use caliptra_api::mailbox::{
CommandId, MailboxReq, MailboxReqHeader, OcpLockInitializeMekSecretReq,
};
use caliptra_hw_model::{HwModel, ModelError};
use caliptra_kat::CaliptraError;
use super::{boot_ocp_lock_runtime, validate_ocp_lock_response, OcpLockBootParams};
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_valid_mek_secret_seed() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams {
hek_available: true,
force_ocp_lock_en: true,
..Default::default()
});
// Initialize MEK Secret Seed
let mut cmd = MailboxReq::OcpLockInitializeMekSecret(OcpLockInitializeMekSecretReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
sek: [0xAB; 32],
dpk: [0xCD; 32],
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_INITIALIZE_MEK_SECRET.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
response.unwrap().unwrap();
});
}
#[cfg_attr(not(feature = "fpga_subsystem"), ignore)]
#[test]
fn test_initialize_mek_secret_no_hek() {
let mut model = boot_ocp_lock_runtime(OcpLockBootParams::default());
let mut cmd = MailboxReq::OcpLockInitializeMekSecret(OcpLockInitializeMekSecretReq {
hdr: MailboxReqHeader { chksum: 0 },
reserved: 0,
sek: [0xAB; 32],
dpk: [0xCD; 32],
});
cmd.populate_chksum().unwrap();
let response = model.mailbox_execute(
CommandId::OCP_LOCK_INITIALIZE_MEK_SECRET.into(),
cmd.as_bytes().unwrap(),
);
validate_ocp_lock_response(&mut model, response, |response, _| {
assert_eq!(
response.unwrap_err(),
ModelError::MailboxCmdFailed(CaliptraError::RUNTIME_OCP_LOCK_HEK_UNAVAILABLE.into(),)
);
});
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/test-fw/build.rs | runtime/test-fw/build.rs | // Licensed under the Apache-2.0 license
fn main() {
cfg_if::cfg_if! {
if #[cfg(not(feature = "std"))] {
cfg_if::cfg_if! {
if #[cfg(feature = "runtime")] {
use std::env;
use std::fs;
use std::path::PathBuf;
use caliptra_gen_linker_scripts::gen_memory_x;
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
// Put the linker script somewhere the linker can find it.
fs::write(out_dir.join("memory.x"),gen_memory_x(caliptra_common::RUNTIME_ORG, caliptra_common::RUNTIME_SIZE)
.as_bytes())
.expect("Unable to generate memory.x");
println!("cargo:rustc-link-search={}", out_dir.display());
println!("cargo:rerun-if-changed=memory.x");
println!("cargo:rustc-link-arg=-Tmemory.x");
println!("cargo:rustc-link-arg=-Tlink.x");
} else {
println!("cargo:rerun-if-changed=../../test-harness/scripts/rom.ld");
println!("cargo:rustc-link-arg=-Ttest-harness/scripts/rom.ld");
}
}
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/test-fw/src/boot_tests.rs | runtime/test-fw/src/boot_tests.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
boot_tests.rs
Abstract:
File contains test cases for booting runtime firmware
--*/
#![no_std]
#![no_main]
use caliptra_common::handle_fatal_error;
use caliptra_registers::soc_ifc::SocIfcReg;
use caliptra_runtime::Drivers;
use caliptra_test_harness::{runtime_handlers, test_suite};
fn test_boot() {
let mut drivers = unsafe {
Drivers::new_from_registers().unwrap_or_else(|e| {
handle_fatal_error(e.into());
})
};
drivers.soc_ifc.assert_ready_for_runtime();
}
test_suite! {
test_boot,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/test-fw/src/mbox_responder.rs | runtime/test-fw/src/mbox_responder.rs | // Licensed under the Apache-2.0 license
#![no_main]
#![no_std]
use core::mem::size_of;
use caliptra_common::{
handle_fatal_error,
keyids::KEY_ID_TMP,
mailbox_api::{CommandId, ExternalMailboxCmdReq},
};
use caliptra_drivers::{
cprintln,
pcr_log::{PCR_ID_STASH_MEASUREMENT, RT_FW_JOURNEY_PCR},
sha2_512_384::Sha2DigestOpTrait,
Array4x12, CaliptraError, CaliptraResult, ResetReason,
};
use caliptra_registers::{mbox::enums::MboxStatusE, soc_ifc::SocIfcReg};
use caliptra_runtime::{
key_ladder::KeyLadder, mailbox::Mailbox, ContextState, Drivers, Hmac, RtBootStatus,
TciMeasurement, U8Bool, MAX_HANDLES,
};
use caliptra_test_harness::{runtime_handlers, test_suite};
use zerocopy::{FromBytes, IntoBytes, TryFromBytes};
const OPCODE_READ_RT_FW_JOURNEY: u32 = 0x1000_0000;
const OPCODE_READ_MBOX_PAUSER_HASH: u32 = 0x2000_0000;
const OPCODE_HASH_DPE_TCI_DATA: u32 = 0x3000_0000;
const OPCODE_READ_STASHED_MEASUREMENT_PCR: u32 = 0x5000_0000;
const OPCODE_READ_DPE_ROOT_CONTEXT_MEASUREMENT: u32 = 0x6000_0000;
const OPCODE_READ_DPE_TAGS: u32 = 0x7000_0000;
const OPCODE_CORRUPT_CONTEXT_TAGS: u32 = 0x8000_0000;
const OPCODE_CORRUPT_CONTEXT_HAS_TAG: u32 = 0x9000_0000;
const OPCODE_READ_DPE_INSTANCE: u32 = 0xA000_0000;
const OPCODE_CORRUPT_DPE_INSTANCE: u32 = 0xB000_0000;
const OPCODE_READ_PCR_RESET_COUNTER: u32 = 0xC000_0000;
const OPCODE_CORRUPT_DPE_ROOT_TCI: u32 = 0xD000_0000;
const OPCODE_HOLD_COMMAND_BUSY: u32 = 0xE000_0000;
const OPCODE_READ_KEY_LADDER_MAX_SVN: u32 = 0xF000_0000;
const OPCODE_OCP_LOCK_HEK_STATE: u32 = 0xF100_0000;
const OPCODE_READ_KEY_LADDER_DIGEST: u32 = 0x1000_1000;
const OPCODE_FW_LOAD: u32 = CommandId::FIRMWARE_LOAD.0;
fn read_request(mbox: &Mailbox) -> &[u8] {
let size = mbox.dlen() as usize;
&mbox.raw_mailbox_contents()[..size]
}
fn write_response(mbox: &mut Mailbox, data: &[u8]) {
mbox.write_response(data).unwrap();
mbox.set_status(MboxStatusE::DataReady);
}
const BANNER: &str = r#"
____ _ _ _ ____ _____
/ ___|__ _| (_)_ __ | |_ _ __ __ _ | _ \_ _|
| | / _` | | | '_ \| __| '__/ _` | | |_) || |
| |__| (_| | | | |_) | |_| | | (_| | | _ < | |
\____\__,_|_|_| .__/ \__|_| \__,_| |_| \_\|_|
|_|
"#;
#[no_mangle]
#[allow(clippy::empty_loop)]
fn rt_entry() {
cprintln!("{}", BANNER);
let mut drivers = unsafe {
Drivers::new_from_registers().unwrap_or_else(|e| {
cprintln!("[rt] Runtime can't load drivers");
handle_fatal_error(e.into());
})
};
drivers.run_reset_flow().unwrap_or_else(|e| {
cprintln!("[rt] Runtime failed reset flow");
handle_fatal_error(e.into());
});
if !drivers.persistent_data.get().rom.fht.is_valid() {
cprintln!("Runtime can't load FHT");
handle_fatal_error(CaliptraError::RUNTIME_HANDOFF_FHT_NOT_LOADED.into());
}
cprintln!("[rt] Runtime listening for mailbox commands...");
if let Err(e) = handle_mailbox_commands(&mut drivers) {
handle_fatal_error(e.into());
}
}
pub fn handle_mailbox_commands(drivers: &mut Drivers) -> CaliptraResult<()> {
// Indicator to SOC that RT firmware is ready
drivers.soc_ifc.assert_ready_for_runtime();
caliptra_drivers::report_boot_status(RtBootStatus::RtReadyForCommands.into());
let command_was_running = drivers
.persistent_data
.get()
.fw
.dpe
.runtime_cmd_active
.get();
if command_was_running {
let reset_reason = drivers.soc_ifc.reset_reason();
if reset_reason == ResetReason::WarmReset {
caliptra_drivers::report_fw_error_non_fatal(
CaliptraError::RUNTIME_CMD_BUSY_DURING_WARM_RESET.into(),
);
}
}
loop {
if drivers.is_shutdown {
return Err(CaliptraError::RUNTIME_SHUTDOWN);
}
drivers.soc_ifc.flow_status_set_mailbox_flow_done(true);
if drivers.mbox.is_cmd_ready() {
drivers.soc_ifc.flow_status_set_mailbox_flow_done(false);
caliptra_drivers::clear_fw_error_non_fatal(drivers.persistent_data.get_mut());
match handle_command(drivers) {
Ok(status) => {
drivers.mbox.set_status(status);
}
Err(e) => {
caliptra_drivers::report_fw_error_non_fatal(e.into());
drivers.mbox.set_status(MboxStatusE::CmdFailure);
}
}
}
}
}
pub fn handle_command(drivers: &mut Drivers) -> CaliptraResult<MboxStatusE> {
loop {
while !drivers.mbox.is_cmd_ready() {
// Wait for a request from the SoC.
}
let cmd = drivers.mbox.cmd();
// Handle external mailbox command if in subsystem mode
if drivers.soc_ifc.subsystem_mode() && cmd == CommandId::EXTERNAL_MAILBOX_CMD {
let input_bytes = read_request(&drivers.mbox);
let external_cmd = ExternalMailboxCmdReq::read_from_bytes(input_bytes)
.map_err(|_| CaliptraError::RUNTIME_INSUFFICIENT_MEMORY)?;
// Only FIRMWARE_LOAD is supported as external command
if external_cmd.command_id == CommandId::FIRMWARE_LOAD.0 {
cprintln!("[rt-test] Received external FIRMWARE_LOAD command, triggering reset");
unsafe { SocIfcReg::new() }
.regs_mut()
.internal_fw_update_reset()
.write(|w| w.core_rst(true));
// Should not reach here
return Err(CaliptraError::RUNTIME_UNEXPECTED_UPDATE_RETURN);
} else {
cprintln!(
"[rt-test] External command 0x{:x} not supported, only FIRMWARE_LOAD allowed",
external_cmd.command_id
);
return Err(CaliptraError::RUNTIME_UNIMPLEMENTED_COMMAND);
}
}
match cmd {
CommandId(OPCODE_READ_RT_FW_JOURNEY) => {
let rt_journey_pcr: [u8; 48] = drivers.pcr_bank.read_pcr(RT_FW_JOURNEY_PCR).into();
write_response(&mut drivers.mbox, &rt_journey_pcr);
}
CommandId(OPCODE_READ_MBOX_PAUSER_HASH) => {
const PAUSER_COUNT: usize = 5;
let mbox_valid_pauser: [u32; PAUSER_COUNT] = drivers.soc_ifc.mbox_valid_pauser();
let mbox_pauser_lock: [bool; PAUSER_COUNT] = drivers.soc_ifc.mbox_pauser_lock();
let mut digest_op = drivers.sha2_512_384.sha384_digest_init().unwrap();
for i in 0..PAUSER_COUNT {
if mbox_pauser_lock[i] {
digest_op.update(mbox_valid_pauser[i].as_bytes()).unwrap();
}
}
let mut valid_pauser_hash = Array4x12::default();
digest_op.finalize(&mut valid_pauser_hash).unwrap();
write_response(&mut drivers.mbox, valid_pauser_hash.as_bytes());
}
CommandId(OPCODE_HASH_DPE_TCI_DATA) => {
let mut hasher = drivers.sha2_512_384.sha384_digest_init().unwrap();
for context in drivers.persistent_data.get().fw.dpe.state.contexts {
if context.state != ContextState::Inactive {
hasher.update(context.tci.tci_current.as_bytes()).unwrap();
}
}
let mut digest = Array4x12::default();
hasher.finalize(&mut digest).unwrap();
write_response(&mut drivers.mbox, &<[u8; 48]>::from(digest));
}
CommandId(OPCODE_READ_STASHED_MEASUREMENT_PCR) => {
let pcr_id_stash_measurement: [u8; 48] =
drivers.pcr_bank.read_pcr(PCR_ID_STASH_MEASUREMENT).into();
write_response(&mut drivers.mbox, &pcr_id_stash_measurement);
}
CommandId(OPCODE_READ_DPE_ROOT_CONTEXT_MEASUREMENT) => {
let root_idx =
Drivers::get_dpe_root_context_idx(&drivers.persistent_data.get().fw.dpe.state)
.unwrap();
let root_measurement = drivers.persistent_data.get().fw.dpe.state.contexts
[root_idx]
.tci
.tci_current
.as_bytes();
write_response(&mut drivers.mbox, root_measurement);
}
CommandId(OPCODE_READ_DPE_TAGS) => {
let context_tags = drivers.persistent_data.get().fw.dpe.context_tags;
let context_has_tag = drivers.persistent_data.get().fw.dpe.context_has_tag;
const CONTEXT_TAGS_SIZE: usize = MAX_HANDLES * size_of::<u32>();
const CONTEXT_HAS_TAG_SIZE: usize = MAX_HANDLES * size_of::<U8Bool>();
let mut tags_info = [0u8; CONTEXT_TAGS_SIZE + CONTEXT_HAS_TAG_SIZE];
tags_info[..CONTEXT_TAGS_SIZE].copy_from_slice(context_tags.as_bytes());
tags_info[CONTEXT_TAGS_SIZE..].copy_from_slice(context_has_tag.as_bytes());
write_response(&mut drivers.mbox, tags_info.as_bytes());
}
CommandId(OPCODE_CORRUPT_CONTEXT_TAGS) => {
let input_bytes = read_request(&drivers.mbox);
let corrupted_context_tags =
<[u32; MAX_HANDLES]>::read_from_bytes(input_bytes).unwrap();
drivers.persistent_data.get_mut().fw.dpe.context_tags = corrupted_context_tags;
write_response(&mut drivers.mbox, &[]);
}
CommandId(OPCODE_CORRUPT_CONTEXT_HAS_TAG) => {
let input_bytes = read_request(&drivers.mbox);
// NOTE: `read_from_bytes` is not used here to avoid an alignment exception.
let corrupted_context_has_tag =
<[U8Bool; MAX_HANDLES]>::ref_from_bytes(input_bytes).unwrap();
drivers
.persistent_data
.get_mut()
.fw
.dpe
.context_has_tag
.clone_from_slice(corrupted_context_has_tag);
write_response(&mut drivers.mbox, &[]);
}
CommandId(OPCODE_READ_DPE_INSTANCE) => {
write_response(
&mut drivers.mbox,
drivers.persistent_data.get().fw.dpe.state.as_bytes(),
);
}
CommandId(OPCODE_CORRUPT_DPE_INSTANCE) => {
let input_bytes = read_request(&drivers.mbox);
let corrupted_dpe = dpe::State::try_read_from_bytes(input_bytes).unwrap();
drivers.persistent_data.get_mut().fw.dpe.state = corrupted_dpe;
write_response(&mut drivers.mbox, &[]);
}
CommandId(OPCODE_READ_PCR_RESET_COUNTER) => {
write_response(
&mut drivers.mbox,
drivers.persistent_data.get().fw.pcr_reset.as_bytes(),
);
}
CommandId(OPCODE_CORRUPT_DPE_ROOT_TCI) => {
let input_bytes = read_request(&drivers.mbox);
let root_idx =
Drivers::get_dpe_root_context_idx(&drivers.persistent_data.get().fw.dpe.state)
.unwrap();
drivers.persistent_data.get_mut().fw.dpe.state.contexts[root_idx]
.tci
.tci_current = TciMeasurement(input_bytes.try_into().unwrap());
write_response(&mut drivers.mbox, &[]);
}
CommandId(OPCODE_READ_KEY_LADDER_MAX_SVN) => {
write_response(
&mut drivers.mbox,
&drivers
.persistent_data
.get()
.rom
.fht
.fw_key_ladder_max_svn
.to_le_bytes(),
);
}
CommandId(OPCODE_OCP_LOCK_HEK_STATE) => {
let hek_available = drivers
.persistent_data
.get()
.rom
.ocp_lock_metadata
.hek_available;
let state = U8Bool::new(hek_available);
write_response(&mut drivers.mbox, &state.as_bytes());
}
// Computes a digest from the key ladder for a given target SVN.
CommandId(OPCODE_READ_KEY_LADDER_DIGEST) => {
let target_svn = u32::read_from_bytes(read_request(&drivers.mbox)).unwrap();
KeyLadder::derive_secret(drivers, target_svn, b"", KEY_ID_TMP)?;
let digest = Hmac::ecc384_hmac(drivers, KEY_ID_TMP, b"label", b"data").unwrap();
drivers.key_vault.erase_key(KEY_ID_TMP).unwrap();
write_response(&mut drivers.mbox, digest.as_bytes());
}
CommandId(OPCODE_FW_LOAD) => {
unsafe { SocIfcReg::new() }
.regs_mut()
.internal_fw_update_reset()
.write(|w| w.core_rst(true));
}
CommandId(OPCODE_HOLD_COMMAND_BUSY) => {
drivers.persistent_data.get_mut().fw.dpe.runtime_cmd_active = U8Bool::new(true);
write_response(&mut drivers.mbox, &[]);
}
_ => {
drivers.mbox.set_status(MboxStatusE::CmdFailure);
}
}
}
}
test_suite! {
rt_entry,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/test-fw/src/mock_rt_test_interactive.rs | runtime/test-fw/src/mock_rt_test_interactive.rs | // Licensed under the Apache-2.0 license
#![no_main]
#![no_std]
use caliptra_common::{
handle_fatal_error,
mailbox_api::{CommandId, ExternalMailboxCmdReq},
};
use caliptra_drivers::pcr_log::{PcrLogEntry, PcrLogEntryId};
use caliptra_drivers::{cprintln, CaliptraError, CaliptraResult};
use caliptra_drivers::{PcrBank, PcrId, PersistentDataAccessor};
use caliptra_registers::pv::PvReg;
use caliptra_registers::{mbox::enums::MboxStatusE, soc_ifc::SocIfcReg};
use caliptra_runtime::{mailbox::Mailbox, Drivers, RtBootStatus};
use caliptra_test_harness::{runtime_handlers, test_suite};
use zerocopy::{FromBytes, IntoBytes};
const OPCODE_FW_LOAD: u32 = CommandId::FIRMWARE_LOAD.0;
const BANNER: &str = r#"FMC Tester"#;
pub const TEST_CMD_READ_PCR_LOG: u32 = 0x1000_0000;
pub const TEST_CMD_READ_FHT: u32 = 0x1000_0001;
pub const TEST_CMD_READ_PCRS: u32 = 0x1000_0002;
pub const TEST_CMD_PCRS_LOCKED: u32 = 0x1000_0004;
#[no_mangle]
#[allow(clippy::empty_loop)]
fn rt_entry() {
cprintln!("{}", BANNER);
let mut drivers = unsafe {
Drivers::new_from_registers().unwrap_or_else(|e| {
cprintln!("[rt] Runtime can't load drivers");
handle_fatal_error(e.into());
})
};
drivers.run_reset_flow().unwrap_or_else(|e| {
cprintln!("[rt] Runtime failed reset flow");
handle_fatal_error(e.into());
});
if !drivers.persistent_data.get().rom.fht.is_valid() {
cprintln!("Runtime can't load FHT");
handle_fatal_error(CaliptraError::RUNTIME_HANDOFF_FHT_NOT_LOADED.into());
}
cprintln!("[rt] Runtime listening for mailbox commands...");
if let Err(e) = handle_mailbox_commands(&mut drivers) {
handle_fatal_error(e.into());
}
}
pub fn handle_mailbox_commands(drivers: &mut Drivers) -> CaliptraResult<()> {
// Indicator to SOC that RT firmware is ready
drivers.soc_ifc.assert_ready_for_runtime();
caliptra_drivers::report_boot_status(RtBootStatus::RtReadyForCommands.into());
let persistent_data = unsafe { PersistentDataAccessor::new() };
loop {
if drivers.is_shutdown {
return Err(CaliptraError::RUNTIME_SHUTDOWN);
}
if drivers.mbox.is_cmd_ready() {
caliptra_drivers::clear_fw_error_non_fatal(drivers.persistent_data.get_mut());
match handle_command(drivers, &persistent_data) {
Ok(status) => {
drivers.mbox.set_status(status);
}
Err(e) => {
caliptra_drivers::report_fw_error_non_fatal(e.into());
drivers.mbox.set_status(MboxStatusE::CmdFailure);
}
}
}
}
}
fn read_request(mbox: &Mailbox) -> &[u8] {
let size = mbox.dlen() as usize;
&mbox.raw_mailbox_contents()[..size]
}
pub fn handle_command(
drivers: &mut Drivers,
persistent_data: &PersistentDataAccessor,
) -> CaliptraResult<MboxStatusE> {
loop {
while !drivers.mbox.is_cmd_ready() {
// Wait for a request from the SoC.
}
let cmd = drivers.mbox.cmd();
// Handle external mailbox command if in subsystem mode
if drivers.soc_ifc.subsystem_mode() && cmd == CommandId::EXTERNAL_MAILBOX_CMD {
let input_bytes = read_request(&drivers.mbox);
let external_cmd = ExternalMailboxCmdReq::read_from_bytes(input_bytes)
.map_err(|_| CaliptraError::RUNTIME_INSUFFICIENT_MEMORY)?;
// Only FIRMWARE_LOAD is supported as external command
if external_cmd.command_id == CommandId::FIRMWARE_LOAD.0 {
cprintln!("[rt-test] Received external FIRMWARE_LOAD command, triggering reset");
unsafe { SocIfcReg::new() }
.regs_mut()
.internal_fw_update_reset()
.write(|w| w.core_rst(true));
// Should not reach here
return Err(CaliptraError::RUNTIME_UNEXPECTED_UPDATE_RETURN);
} else {
cprintln!(
"[rt-test] External command 0x{:x} not supported, only FIRMWARE_LOAD allowed",
external_cmd.command_id
);
return Err(CaliptraError::RUNTIME_UNIMPLEMENTED_COMMAND);
}
}
let mbox = &mut drivers.mbox;
match cmd {
CommandId(OPCODE_FW_LOAD) => trigger_update_reset(),
CommandId(TEST_CMD_READ_PCR_LOG) => read_pcr_log(persistent_data, mbox),
CommandId(TEST_CMD_READ_FHT) => read_fht(persistent_data, mbox),
CommandId(TEST_CMD_READ_PCRS) => read_pcrs(mbox),
CommandId(TEST_CMD_PCRS_LOCKED) => try_to_reset_pcrs(mbox),
_ => {
drivers.mbox.set_status(MboxStatusE::CmdFailure);
}
}
}
}
fn read_pcr_log(persistent_data: &PersistentDataAccessor, mbox: &mut Mailbox) {
let mut pcr_entry_count = 0;
loop {
let pcr_entry = persistent_data.get().rom.pcr_log[pcr_entry_count];
if PcrLogEntryId::from(pcr_entry.id) == PcrLogEntryId::Invalid {
break;
}
pcr_entry_count += 1;
mbox.copy_bytes_to_mbox(pcr_entry.as_bytes()).unwrap();
}
mbox.set_dlen(
(core::mem::size_of::<PcrLogEntry>() * pcr_entry_count)
.try_into()
.unwrap(),
)
.unwrap();
mbox.set_status(MboxStatusE::DataReady);
}
fn read_fht(persistent_data: &PersistentDataAccessor, mbox: &mut Mailbox) {
mbox.write_response(persistent_data.get().rom.fht.as_bytes())
.unwrap();
mbox.set_status(MboxStatusE::DataReady);
}
fn read_pcrs(mbox: &mut Mailbox) {
let pcr_bank = unsafe { PcrBank::new(PvReg::new()) };
const PCR_COUNT: usize = 32;
for i in 0..PCR_COUNT {
let pcr = pcr_bank.read_pcr(PcrId::try_from(i as u8).unwrap());
let mut pcr_bytes: [u32; 12] = pcr.into();
swap_word_bytes_inplace(&mut pcr_bytes);
mbox.copy_bytes_to_mbox(pcr.as_bytes()).unwrap();
}
mbox.set_dlen((48 * PCR_COUNT).try_into().unwrap()).unwrap();
mbox.set_status(MboxStatusE::DataReady);
}
fn swap_word_bytes_inplace(words: &mut [u32]) {
for word in words.iter_mut() {
*word = word.swap_bytes()
}
}
fn try_to_reset_pcrs(mbox: &mut Mailbox) {
let mut pcr_bank = unsafe { PcrBank::new(PvReg::new()) };
let res0 = pcr_bank.erase_pcr(caliptra_common::RT_FW_CURRENT_PCR);
let res1 = pcr_bank.erase_pcr(caliptra_common::RT_FW_JOURNEY_PCR);
if res0.is_err() && res1.is_err() {
mbox.set_status(MboxStatusE::CmdComplete);
} else {
mbox.set_status(MboxStatusE::CmdComplete);
}
}
fn trigger_update_reset() {
unsafe { SocIfcReg::new() }
.regs_mut()
.internal_fw_update_reset()
.write(|w| w.core_rst(true));
}
test_suite! {
rt_entry,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/runtime/test-fw/src/persistent_tests.rs | runtime/test-fw/src/persistent_tests.rs | // Licensed under the Apache-2.0 license
#![no_std]
#![no_main]
use caliptra_common::handle_fatal_error;
use caliptra_drivers::{PersistentData, PersistentDataAccessor};
use caliptra_registers::soc_ifc::SocIfcReg;
use caliptra_runtime::Drivers;
use caliptra_test_harness::{runtime_handlers, test_suite};
fn test_persistent_data_layout() {
let mut drivers = unsafe {
Drivers::new_from_registers().unwrap_or_else(|e| {
handle_fatal_error(e.into());
})
};
// Set this to signal we're in runtime
drivers.soc_ifc.assert_ready_for_runtime();
PersistentData::assert_matches_layout();
}
fn test_read_write() {
{
let mut accessor = unsafe { PersistentDataAccessor::new() };
accessor.get_mut().rom.fht.fht_marker = 0xfe9cd1c0;
}
{
let accessor = unsafe { PersistentDataAccessor::new() };
assert_eq!(accessor.get().rom.fht.fht_marker, 0xfe9cd1c0);
}
}
test_suite! {
test_persistent_data_layout,
test_read_write,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/build.rs | rom/dev/build.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
build.rs
Abstract:
Build script for Caliptra ROM.
--*/
use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;
use caliptra_common::x509::get_tbs;
fn preprocess(filename: &str, defines: &[(String, String)]) -> Vec<u8> {
let mut cmd = Command::new("cc");
cmd.arg("-E");
for (key, val) in defines {
cmd.arg(format!("-D{key}={val}"));
}
cmd.arg(filename);
let out = cmd.output().unwrap();
if !out.status.success() {
panic!(
"failed to use cc preprocessor {} {}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
}
out.stdout
}
fn workspace_dir() -> PathBuf {
let output = std::process::Command::new(env!("CARGO"))
.arg("locate-project")
.arg("--workspace")
.arg("--message-format=plain")
.output()
.unwrap()
.stdout;
let cargo_path = Path::new(std::str::from_utf8(&output).unwrap().trim());
cargo_path.parent().unwrap().to_path_buf()
}
fn be_bytes_to_words(src: &[u8]) -> Vec<u32> {
let mut dst = Vec::<u32>::new();
for i in (0..src.len()).step_by(4) {
dst.push(u32::from_be_bytes(src[i..i + 4].try_into().unwrap()));
}
dst
}
fn main() {
if cfg!(not(feature = "std")) {
use std::fs;
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
fs::write(out_dir.join("rom.ld"), include_bytes!("src/rom.ld")).unwrap();
let preprocessor_vars: Vec<_> = env::vars()
.filter(|(k, _)| k.starts_with("CARGO_"))
.collect();
std::fs::write(
out_dir.join("start_preprocessed.S"),
preprocess("src/start.S", &preprocessor_vars),
)
.unwrap();
println!("cargo:rustc-link-search={}", out_dir.display());
println!("cargo:rustc-link-arg=-Trom.ld");
println!("cargo:rerun-if-changed=src/rom.ld");
println!("cargo:rerun-if-changed=src/start.S");
println!("cargo:rerun-if-changed=build.rs");
}
if cfg!(feature = "fake-rom") {
use const_gen::*;
use openssl::bn::{BigNum, BigNumContext};
use openssl::ec::EcGroup;
use openssl::ecdsa::EcdsaSig;
use openssl::nid::Nid;
#[derive(CompileConst)]
struct Array4xN(pub [u32; 12]);
#[derive(CompileConst)]
struct Ecc384PubKey {
pub x: Array4xN,
pub y: Array4xN,
}
#[derive(CompileConst)]
pub struct Ecc384Signature {
pub r: Array4xN,
pub s: Array4xN,
}
let ws_dir = workspace_dir();
// Create a closure to process ECC certificates
let group = EcGroup::from_curve_name(Nid::SECP384R1).unwrap();
let mut ctx = BigNumContext::new().unwrap();
let mut process_ecc_cert = |cert_path: &str| -> (Ecc384PubKey, Ecc384Signature, Vec<u8>) {
let file_path = ws_dir.join(cert_path);
println!("cargo:rerun-if-changed={}", file_path.to_str().unwrap());
let file_data = std::fs::read(&file_path).unwrap();
let cert = openssl::x509::X509::from_der(&file_data).unwrap();
let tbs = get_tbs(file_data);
// Extract public key
let pubkey = cert.public_key().unwrap();
let pubkey = pubkey.ec_key().unwrap();
let pubkey = pubkey.public_key();
let mut x = BigNum::new().unwrap();
let mut y = BigNum::new().unwrap();
pubkey
.affine_coordinates(&group, &mut x, &mut y, &mut ctx)
.unwrap();
let x_vec = x.to_vec();
let x_words = be_bytes_to_words(&x_vec);
let y_vec = y.to_vec();
let y_words = be_bytes_to_words(&y_vec);
let ecc_pubkey = Ecc384PubKey {
x: Array4xN(x_words.try_into().unwrap()),
y: Array4xN(y_words.try_into().unwrap()),
};
// Extract signature
let signature = cert.signature().as_slice();
let signature = EcdsaSig::from_der(signature).unwrap();
let r = signature.r().to_vec();
let r_words = be_bytes_to_words(&r);
let s = signature.s().to_vec();
let s_words = be_bytes_to_words(&s);
let ecc_signature = Ecc384Signature {
r: Array4xN(r_words.try_into().unwrap()),
s: Array4xN(s_words.try_into().unwrap()),
};
(ecc_pubkey, ecc_signature, tbs)
};
// Process LDEVID ECC certificate
let (ecc_ldev_pubkey, ecc_ldev_signature, ecc_ldev_tbs) = process_ecc_cert(
"test/tests/caliptra_integration_tests/smoke_testdata/ldevid_cert_ecc.der",
);
// Process FMC alias ECC certificate
let (ecc_fmc_pubkey, ecc_fmc_signature, ecc_fmc_tbs) = process_ecc_cert(
"test/tests/caliptra_integration_tests/smoke_testdata/fmc_alias_cert_ecc.der",
);
// Create a closure to process MLDSA certificates
let process_mldsa_cert = |cert_path: &str| -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let file_path = ws_dir.join(cert_path);
println!("cargo:rerun-if-changed={}", file_path.to_str().unwrap());
let file_data = std::fs::read(&file_path).unwrap();
let cert = openssl::x509::X509::from_der(&file_data).unwrap();
let tbs = get_tbs(file_data);
// Extract public key
let pubkey = cert.public_key().unwrap().raw_public_key().unwrap();
// Pad MLDSA signature
let mut signature = vec![0; 4628];
signature[..4627].copy_from_slice(cert.signature().as_slice());
(pubkey, signature, tbs)
};
// Process LDEVID MLDSA certificate
let (mldsa_ldev_pubkey, mldsa_ldev_signature, mldsa_ldev_tbs) = process_mldsa_cert(
"test/tests/caliptra_integration_tests/smoke_testdata/ldevid_cert_mldsa.der",
);
// Process FMC alias MLDSA certificate
let (mldsa_fmc_pubkey, mldsa_fmc_signature, mldsa_fmc_tbs) = process_mldsa_cert(
"test/tests/caliptra_integration_tests/smoke_testdata/fmc_alias_cert_mldsa.der",
);
// Generate Rust constants for all certificates
let const_declarations = vec![
const_array_declaration!(pub FAKE_FMC_ALIAS_ECC_TBS = ecc_fmc_tbs),
const_array_declaration!(pub FAKE_FMC_ALIAS_MLDSA_PUB_KEY = mldsa_fmc_pubkey),
const_array_declaration!(pub FAKE_FMC_ALIAS_MLDSA_SIG = mldsa_fmc_signature),
const_array_declaration!(pub FAKE_FMC_ALIAS_MLDSA_TBS = mldsa_fmc_tbs),
const_array_declaration!(pub FAKE_LDEV_ECC_TBS = ecc_ldev_tbs),
const_array_declaration!(pub FAKE_LDEV_MLDSA_PUB_KEY = mldsa_ldev_pubkey),
const_array_declaration!(pub FAKE_LDEV_MLDSA_SIG = mldsa_ldev_signature),
const_array_declaration!(pub FAKE_LDEV_MLDSA_TBS = mldsa_ldev_tbs),
const_declaration!(pub FAKE_FMC_ALIAS_ECC_PUB_KEY = ecc_fmc_pubkey),
const_declaration!(pub FAKE_FMC_ALIAS_ECC_SIG = ecc_fmc_signature),
const_declaration!(pub FAKE_LDEV_ECC_PUB_KEY = ecc_ldev_pubkey),
const_declaration!(pub FAKE_LDEV_ECC_SIG = ecc_ldev_signature),
]
.join("\n");
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
std::fs::write(out_dir.join("fake_consts.rs"), const_declarations).unwrap();
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/mldsa_key_pair_gen/src/main.rs | rom/dev/tools/mldsa_key_pair_gen/src/main.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
main.rs
Abstract:
File contains app for generating MLDSA key pairs from FIPS204 library.
--*/
use fips204::ml_dsa_87::try_keygen_with_rng;
use fips204::traits::SerDes;
use rand::prelude::*;
use rand::rngs::StdRng;
use std::fs::{self, File};
use std::io::Write;
fn write_to_file(filename: &str, bytes: &[u8]) {
let mut w = File::create(filename).unwrap();
w.write_all(bytes).unwrap();
}
fn main() {
let mut seed_bytes = [0u8; 32];
let mut rng = rand::thread_rng();
rng.fill_bytes(&mut seed_bytes);
let mut seeded_rng = StdRng::from_seed(seed_bytes);
for i in 0..5 {
let (pk, sk) = try_keygen_with_rng(&mut seeded_rng).unwrap();
let pk = pk.into_bytes();
let sk = sk.into_bytes();
let dir = "../mldsa_keys";
fs::create_dir_all(dir).unwrap();
let mut pub_file = format!("{}/vnd-mldsa-pub-key-{}.bin", dir, i);
let mut priv_file = format!("{}/vnd-mldsa-priv-key-{}.bin", dir, i);
if i == 4 {
pub_file = format!("{}/own-mldsa-pub-key.bin", dir);
priv_file = format!("{}/own-mldsa-priv-key.bin", dir);
}
// Write the keys in the library format.
// For MLDSA, library format is same as hardware format.
write_to_file(&pub_file, &pk);
write_to_file(&priv_file, &sk);
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-rt/build.rs | rom/dev/tools/test-rt/build.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
build.rs
Abstract:
Build script for Caliptra ROM Test Runtime.
--*/
fn main() {
cfg_if::cfg_if! {
if #[cfg(not(feature = "std"))] {
use std::env;
use std::fs;
use std::path::PathBuf;
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
let ld_script = include_str!("src/rt.ld")
.replace("#MANIFEST_SIZE#", &caliptra_image_types::IMAGE_MANIFEST_BYTE_SIZE.to_string());
fs::write(out_dir.join("rt.ld"), ld_script).unwrap();
println!("cargo:rustc-link-search={}", out_dir.display());
println!("cargo:rustc-link-arg=-Trt.ld");
println!("cargo:rerun-if-changed=src/rt.ld");
println!("cargo:rerun-if-changed=src/start.S");
println!("cargo:rerun-if-changed=build.rs");
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-rt/src/exception.rs | rom/dev/tools/test-rt/src/exception.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
exception.rs
Abstract:
File contains exception related structures
--*/
/// Exception Record
#[repr(C)]
pub(crate) struct ExceptionRecord {
pub ra: u32,
pub sp: u32,
pub a0: u32,
pub a1: u32,
pub a2: u32,
pub a3: u32,
pub a4: u32,
pub a5: u32,
pub a6: u32,
pub a7: u32,
pub t0: u32,
pub t1: u32,
pub t2: u32,
pub t3: u32,
pub t4: u32,
pub t5: u32,
pub t6: u32,
pub mepc: u32,
pub mcause: u32,
pub mscause: u32,
pub mstatus: u32,
pub mtval: u32,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-rt/src/main.rs | rom/dev/tools/test-rt/src/main.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
main.rs
Abstract:
File contains main entry point for Caliptra Test Runtime
--*/
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(not(feature = "std"), no_main)]
use caliptra_drivers::Mailbox;
#[cfg(not(feature = "std"))]
core::arch::global_asm!(include_str!("start.S"));
mod exception;
mod print;
#[cfg(feature = "std")]
pub fn main() {}
const BANNER: &str = r#"
____ _ _ _ ____ _____
/ ___|__ _| (_)_ __ | |_ _ __ __ _ | _ \_ _|
| | / _` | | | '_ \| __| '__/ _` | | |_) || |
| |__| (_| | | | |_) | |_| | | (_| | | _ < | |
\____\__,_|_|_| .__/ \__|_| \__,_| |_| \_\|_|
|_|
"#;
#[no_mangle]
pub extern "C" fn rt_entry() -> ! {
cprintln!("{}", BANNER);
caliptra_drivers::ExitCtrl::exit(0)
}
#[no_mangle]
#[inline(never)]
#[allow(clippy::empty_loop)]
extern "C" fn exception_handler(exception: &exception::ExceptionRecord) {
cprintln!(
"RT EXCEPTION mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
exception.mcause,
exception.mscause,
exception.mepc
);
loop {
unsafe { Mailbox::abort_pending_soc_to_uc_transactions() };
}
}
#[no_mangle]
#[inline(never)]
#[allow(clippy::empty_loop)]
extern "C" fn nmi_handler(exception: &exception::ExceptionRecord) {
cprintln!(
"RT NMI mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
exception.mcause,
exception.mscause,
exception.mepc
);
loop {
unsafe { Mailbox::abort_pending_soc_to_uc_transactions() };
}
}
#[panic_handler]
#[inline(never)]
#[cfg(not(feature = "std"))]
#[allow(clippy::empty_loop)]
fn fmc_panic(_: &core::panic::PanicInfo) -> ! {
cprintln!("RT Panic!!");
loop {}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-rt/src/print.rs | rom/dev/tools/test-rt/src/print.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
pring.rs
Abstract:
File contains support routines and macros to print to UART
--*/
use core::convert::Infallible;
use ufmt::uWrite;
#[derive(Default)]
pub struct RomPrinter;
impl uWrite for RomPrinter {
type Error = Infallible;
/// Writes a string slice into this writer, returning whether the write succeeded.
#[cfg(not(feature = "std"))]
#[inline(never)]
fn write_str(&mut self, _str: &str) -> Result<(), Self::Error> {
#[cfg(feature = "emu")]
caliptra_drivers::Uart::default().write(_str);
Ok(())
}
/// Writes a string slice into this writer, returning whether the write succeeded.
#[cfg(feature = "std")]
fn write_str(&mut self, str: &str) -> Result<(), Self::Error> {
print!("{str}");
Ok(())
}
}
#[macro_export]
macro_rules! cprint {
($($tt:tt)*) => {{
let _ = ufmt::uwrite!(&mut $crate::print::RomPrinter::default(), $($tt)*);
}}
}
#[macro_export]
macro_rules! cprintln {
($($tt:tt)*) => {{
let _ = ufmt::uwriteln!(&mut $crate::print::RomPrinter::default(), $($tt)*);
}}
}
#[macro_export]
macro_rules! cprint_slice {
($name:expr, $arr:expr) => {
$crate::cprint!("{} = ", $name);
for byte in $arr {
$crate::cprint!("{:02X}" byte);
}
$crate::cprintln!("");
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-fmc/build.rs | rom/dev/tools/test-fmc/build.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
build.rs
Abstract:
Build script for Caliptra ROM Test FMC.
--*/
fn main() {
cfg_if::cfg_if! {
if #[cfg(not(feature = "std"))] {
use std::env;
use std::fs;
use std::path::PathBuf;
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
fs::write(out_dir.join("fmc.ld"), include_bytes!("src/fmc.ld")).unwrap();
println!("cargo:rustc-link-search={}", out_dir.display());
println!("cargo:rustc-link-arg=-Tfmc.ld");
println!("cargo:rerun-if-changed=src/fmc.ld");
println!("cargo:rerun-if-changed=src/start.S");
println!("cargo:rerun-if-changed=build.rs");
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-fmc/src/exception.rs | rom/dev/tools/test-fmc/src/exception.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
exception.rs
Abstract:
File contains exception related structures
--*/
/// Exception Record
#[repr(C)]
pub(crate) struct ExceptionRecord {
pub ra: u32,
pub sp: u32,
pub a0: u32,
pub a1: u32,
pub a2: u32,
pub a3: u32,
pub a4: u32,
pub a5: u32,
pub a6: u32,
pub a7: u32,
pub t0: u32,
pub t1: u32,
pub t2: u32,
pub t3: u32,
pub t4: u32,
pub t5: u32,
pub t6: u32,
pub mepc: u32,
pub mcause: u32,
pub mscause: u32,
pub mstatus: u32,
pub mtval: u32,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-fmc/src/main.rs | rom/dev/tools/test-fmc/src/main.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
main.rs
Abstract:
File contains main entry point for Caliptra ROM Test FMC
--*/
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(not(feature = "std"), no_main)]
use caliptra_common::pcr::PCR_ID_STASH_MEASUREMENT;
use caliptra_common::PcrLogEntry;
use caliptra_common::{mailbox_api, FuseLogEntry, FuseLogEntryId};
use caliptra_drivers::pcr_log::MeasurementLogEntry;
use caliptra_drivers::{
DataVault, LEArray4x8, Mailbox, PcrBank, PcrId, PersistentDataAccessor, SocIfc,
};
use caliptra_registers::pv::PvReg;
use caliptra_registers::soc_ifc::SocIfcReg;
use caliptra_x509::{
Ecdsa384CertBuilder, Ecdsa384Signature, FmcAliasCertTbsEcc384, LocalDevIdCertTbsEcc384,
};
use ureg::RealMmioMut;
use zerocopy::IntoBytes;
#[cfg(not(feature = "std"))]
core::arch::global_asm!(include_str!("start.S"));
mod exception;
mod print;
const FW_LOAD_CMD_OPCODE: u32 = mailbox_api::CommandId::FIRMWARE_LOAD.0;
const EXTERNAL_CMD_OPCODE: u32 = mailbox_api::CommandId::EXTERNAL_MAILBOX_CMD.0;
#[cfg(feature = "std")]
pub fn main() {}
const BANNER: &str = r#"
Running Caliptra FMC ...
"#;
#[no_mangle]
pub extern "C" fn fmc_entry() -> ! {
cprintln!("{}", BANNER);
if cfg!(not(feature = "fake-fmc")) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
assert!(persistent_data.get().rom.fht.is_valid());
}
process_mailbox_commands();
caliptra_drivers::ExitCtrl::exit(0)
}
#[no_mangle]
#[inline(never)]
#[allow(clippy::empty_loop)]
extern "C" fn exception_handler(exception: &exception::ExceptionRecord) {
cprintln!(
"FMC EXCEPTION mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
exception.mcause,
exception.mscause,
exception.mepc
);
{
let mut soc_ifc = unsafe { SocIfcReg::new() };
let soc_ifc = soc_ifc.regs_mut();
let ext_info = soc_ifc.cptra_fw_extended_error_info();
ext_info.at(0).write(|_| exception.mcause);
ext_info.at(1).write(|_| exception.mscause);
ext_info.at(2).write(|_| exception.mepc);
ext_info.at(3).write(|_| exception.ra);
}
loop {
unsafe { Mailbox::abort_pending_soc_to_uc_transactions() };
}
}
#[no_mangle]
#[inline(never)]
#[allow(clippy::empty_loop)]
extern "C" fn nmi_handler(exception: &exception::ExceptionRecord) {
cprintln!(
"FMC NMI mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X}",
exception.mcause,
exception.mscause,
exception.mepc
);
{
let mut soc_ifc = unsafe { SocIfcReg::new() };
let soc_ifc = soc_ifc.regs_mut();
let ext_info = soc_ifc.cptra_fw_extended_error_info();
ext_info.at(0).write(|_| exception.mcause);
ext_info.at(1).write(|_| exception.mscause);
ext_info.at(2).write(|_| exception.mepc);
ext_info.at(3).write(|_| exception.ra);
}
loop {
unsafe { Mailbox::abort_pending_soc_to_uc_transactions() };
}
}
#[panic_handler]
#[inline(never)]
#[cfg(not(feature = "std"))]
#[allow(clippy::empty_loop)]
fn fmc_panic(_: &core::panic::PanicInfo) -> ! {
cprintln!("FMC Panic!!");
loop {}
}
fn create_certs(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
//
// Create LDEVID cert.
//
// Retrieve the ECC public key and signature from the data vault.
let persistent_data = unsafe { PersistentDataAccessor::new() };
let data_vault = &persistent_data.get().rom.data_vault;
let ldevid_pub_key = data_vault.ldev_dice_ecc_pub_key();
let mut _pub_der: [u8; 97] = ldevid_pub_key.to_der();
cprint_slice!("[fmc] LDEVID PUBLIC KEY DER", _pub_der);
let sig = data_vault.ldev_dice_ecc_signature();
let ecdsa_sig = Ecdsa384Signature {
r: sig.r.into(),
s: sig.s.into(),
};
let mut tbs: [u8; core::mem::size_of::<LocalDevIdCertTbsEcc384>()] =
[0u8; core::mem::size_of::<LocalDevIdCertTbsEcc384>()];
copy_tbs(&mut tbs, true);
let mut cert: [u8; 1024] = [0u8; 1024];
let builder = Ecdsa384CertBuilder::new(
&tbs[..core::mem::size_of::<LocalDevIdCertTbsEcc384>()],
&ecdsa_sig,
)
.unwrap();
let _cert_len = builder.build(&mut cert).unwrap();
cprint_slice_ref!("[fmc] LDEVID cert", &cert[.._cert_len]);
//
// Create FMCALIAS cert.
//
// Retrieve the public key and signature from the data vault.
let fmcalias_pub_key = data_vault.fmc_ecc_pub_key();
let _pub_der: [u8; 97] = fmcalias_pub_key.to_der();
cprint_slice!("[fmc] FMCALIAS PUBLIC KEY DER", _pub_der);
let sig = data_vault.fmc_dice_ecc_signature();
let ecdsa_sig = Ecdsa384Signature {
r: sig.r.into(),
s: sig.s.into(),
};
let mut tbs: [u8; core::mem::size_of::<FmcAliasCertTbsEcc384>()] =
[0u8; core::mem::size_of::<FmcAliasCertTbsEcc384>()];
copy_tbs(&mut tbs, false);
let mut cert: [u8; 1024] = [0u8; 1024];
let builder = Ecdsa384CertBuilder::new(
&tbs[..core::mem::size_of::<FmcAliasCertTbsEcc384>()],
&ecdsa_sig,
)
.unwrap();
let _cert_len = builder.build(&mut cert).unwrap();
cprint_slice_ref!("[fmc] FMCALIAS cert", &cert[.._cert_len]);
mbox.status().write(|w| w.status(|w| w.cmd_complete()));
}
fn copy_tbs(tbs: &mut [u8], ldevid_tbs: bool) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
// Copy the tbs from DCCM
let src = if ldevid_tbs {
&persistent_data.get().rom.ecc_ldevid_tbs
} else {
&persistent_data.get().rom.ecc_fmcalias_tbs
};
tbs.copy_from_slice(&src[..tbs.len()]);
}
fn process_mailbox_command(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
if !mbox.status().read().mbox_fsm_ps().mbox_execute_uc() {
return;
}
let mut cmd = mbox.cmd().read();
cprintln!("[fmc] Received command: 0x{:08X}", cmd);
if cmd == EXTERNAL_CMD_OPCODE {
let _header = mbox.dataout().read();
cmd = mbox.dataout().read();
}
match cmd {
0x1000_0000 => {
read_pcr_log(mbox);
}
0x1000_0001 => {
create_certs(mbox);
}
0x1000_0002 => {
read_fuse_log(mbox);
}
0x1000_0003 => {
read_fht(mbox);
}
0x1000_0004 => {
mbox.status().write(|w| w.status(|w| w.cmd_complete()));
// Reset the CPU with no command in the mailbox
trigger_update_reset();
}
0x1000_0005 => {
read_datavault(mbox);
}
0x1000_0006 => {
read_pcrs(mbox);
}
0x1000_0007 => {
try_to_reset_pcrs(mbox);
}
0x1000_0008 => {
read_rom_info(mbox);
}
0x1000_0009 => {
read_pcr31(mbox);
}
0x1000_000A => {
read_measurement_log(mbox);
}
0x1000_000B => {
// Reset the CPU with an unknown command in the mailbox
trigger_update_reset();
}
FW_LOAD_CMD_OPCODE => {
// Reset the CPU with the firmware-update command in the mailbox
trigger_update_reset();
}
// Exit with success
0x1000_000C => {
mbox.status().write(|w| w.status(|w| w.cmd_complete()));
caliptra_drivers::ExitCtrl::exit(0);
}
0x1000_000E => {
validate_fmc_rt_load_in_iccm(mbox);
}
0x1000_0010 => {
test_datavault_pmp(mbox, true);
}
0x1000_0011 => {
test_datavault_pmp(mbox, false);
}
0x1000_0012 => {
get_cmb_aes_key(mbox);
}
_ => {}
}
}
fn process_mailbox_commands() {
let mut mbox = unsafe { caliptra_registers::mbox::MboxCsr::new() };
let mbox = mbox.regs_mut();
#[cfg(feature = "interactive_test_fmc")]
loop {
if mbox.status().read().mbox_fsm_ps().mbox_execute_uc() {
process_mailbox_command(&mbox);
}
}
#[cfg(not(feature = "interactive_test_fmc"))]
process_mailbox_command(&mbox);
}
fn get_cmb_aes_key(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let key0 = persistent_data.get().rom.cmb_aes_key_share0;
let key1 = persistent_data.get().rom.cmb_aes_key_share1;
let mut key = LEArray4x8::default();
for (i, element) in key.0.iter_mut().enumerate() {
*element = key0.0[i] ^ key1.0[i];
}
let key: [u8; 32] = key.into();
send_to_mailbox(mbox, &key, true);
}
fn test_datavault_pmp(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>, start: bool) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let data_vault = &persistent_data.get().rom.data_vault;
let dv_bytes: &mut [u8] = unsafe {
core::slice::from_raw_parts_mut(
data_vault as *const _ as *mut u8,
core::mem::size_of_val(data_vault),
)
};
mbox.status().write(|w| w.status(|w| w.cmd_complete()));
if start {
dv_bytes[0] = 0xFF;
} else {
dv_bytes[dv_bytes.len() - 1] = 0xFF;
}
}
fn validate_fmc_rt_load_in_iccm(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let data_vault = &persistent_data.get().rom.data_vault;
let fmc_load_addr = data_vault.fmc_entry_point();
let rt_load_addr = data_vault.rt_entry_point();
let fmc_size = mbox.dataout().read() as usize;
let rt_size = mbox.dataout().read() as usize;
let fmc_iccm = unsafe {
let ptr = fmc_load_addr as *mut u32;
core::slice::from_raw_parts_mut(ptr, fmc_size / 4)
};
let rt_iccm = unsafe {
let ptr = rt_load_addr as *mut u32;
core::slice::from_raw_parts_mut(ptr, rt_size / 4)
};
let mut mismatch = false;
// [TODO][CAP2.1] Handle Staging area
let soc_ifc = unsafe { SocIfc::new(SocIfcReg::new()) };
if !soc_ifc.subsystem_mode() {
for (idx, _) in fmc_iccm.iter().enumerate().take(fmc_size / 4) {
let temp = mbox.dataout().read();
if temp != fmc_iccm[idx] {
cprint!(
"FMC load mismatch at index {} (0x{:08X} != 0x{:08X})",
idx,
temp,
fmc_iccm[idx]
);
mismatch = true;
}
}
for (idx, _) in rt_iccm.iter().enumerate().take(rt_size / 4) {
let temp = mbox.dataout().read();
if temp != rt_iccm[idx] {
cprint!(
"RT load mismatch at index {} (0x{:08X} != 0x{:08X})",
idx,
temp,
rt_iccm[idx]
);
mismatch = true;
}
}
}
if mismatch {
send_to_mailbox(mbox, &[1], false);
} else {
send_to_mailbox(mbox, &[0], false);
}
mbox.dlen().write(|_| 1.try_into().unwrap());
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn read_pcr31(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let pcr_bank = unsafe { PcrBank::new(PvReg::new()) };
let pcr31: [u8; 48] = pcr_bank.read_pcr(PCR_ID_STASH_MEASUREMENT).into();
send_to_mailbox(mbox, &pcr31, true);
}
fn read_datavault(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let data_vault = &persistent_data.get().rom.data_vault;
send_to_mailbox(mbox, data_vault.as_bytes(), false);
mbox.dlen()
.write(|_| (core::mem::size_of::<DataVault>()).try_into().unwrap());
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn trigger_update_reset() {
unsafe { SocIfcReg::new() }
.regs_mut()
.internal_fw_update_reset()
.write(|w| w.core_rst(true));
}
fn read_pcr_log(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let pcr_entry_count = persistent_data.get().rom.fht.pcr_log_index as usize;
for i in 0..pcr_entry_count {
let pcr_entry = persistent_data.get().rom.pcr_log[i];
send_to_mailbox(mbox, pcr_entry.as_bytes(), false);
}
mbox.dlen().write(|_| {
(core::mem::size_of::<PcrLogEntry>() * pcr_entry_count)
.try_into()
.unwrap()
});
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn read_measurement_log(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
let measurement_entry_count = persistent_data.get().rom.fht.meas_log_index as usize;
for i in 0..measurement_entry_count {
let meas_entry = persistent_data.get().rom.measurement_log[i];
send_to_mailbox(mbox, meas_entry.as_bytes(), false);
}
mbox.dlen().write(|_| {
(core::mem::size_of::<MeasurementLogEntry>() * measurement_entry_count)
.try_into()
.unwrap()
});
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn swap_word_bytes_inplace(words: &mut [u32]) {
for word in words.iter_mut() {
*word = word.swap_bytes()
}
}
fn read_pcrs(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let pcr_bank = unsafe { PcrBank::new(PvReg::new()) };
const PCR_COUNT: usize = 32;
for i in 0..PCR_COUNT {
let pcr = pcr_bank.read_pcr(PcrId::try_from(i as u8).unwrap());
let mut pcr_bytes: [u32; 12] = pcr.into();
swap_word_bytes_inplace(&mut pcr_bytes);
send_to_mailbox(mbox, pcr.as_bytes(), false);
}
mbox.dlen().write(|_| (48 * PCR_COUNT).try_into().unwrap());
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
// Returns a list of u8 values, 0 on success, 1 on failure:
// - Whether PCR0 is locked
// - Whether PCR1 is locked
// - Whether PCR2 is unlocked
// - Whether PCR31 is locked
fn try_to_reset_pcrs(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let mut pcr_bank = unsafe { PcrBank::new(PvReg::new()) };
let res0 = pcr_bank.erase_pcr(PcrId::PcrId0);
let res1 = pcr_bank.erase_pcr(PcrId::PcrId1);
let res2 = pcr_bank.erase_pcr(PcrId::PcrId2);
let res31 = pcr_bank.erase_pcr(PcrId::PcrId31);
let ret_vals: [u8; 4] = [
if res0.is_err() { 0 } else { 1 },
if res1.is_err() { 0 } else { 1 },
if res2.is_ok() { 0 } else { 1 },
if res31.is_err() { 0 } else { 1 },
];
send_to_mailbox(mbox, &ret_vals, false);
mbox.dlen().write(|_| ret_vals.len().try_into().unwrap());
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn read_rom_info(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
send_to_mailbox(
mbox,
persistent_data
.get()
.rom
.fht
.rom_info_addr
.get()
.unwrap()
.as_bytes(),
true,
);
}
fn read_fuse_log(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let mut fuse_entry_count = 0;
loop {
let fuse_entry = get_fuse_entry(fuse_entry_count);
if FuseLogEntryId::from(fuse_entry.entry_id) == FuseLogEntryId::Invalid {
break;
}
fuse_entry_count += 1;
send_to_mailbox(mbox, fuse_entry.as_bytes(), false);
}
mbox.dlen().write(|_| {
(core::mem::size_of::<FuseLogEntry>() * fuse_entry_count)
.try_into()
.unwrap()
});
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
fn get_fuse_entry(entry_index: usize) -> FuseLogEntry {
let persistent_data = unsafe { PersistentDataAccessor::new() };
persistent_data.get().rom.fuse_log[entry_index]
}
fn read_fht(mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>) {
let persistent_data = unsafe { PersistentDataAccessor::new() };
send_to_mailbox(mbox, persistent_data.get().rom.fht.as_bytes(), true);
}
fn send_to_mailbox(
mbox: &caliptra_registers::mbox::RegisterBlock<RealMmioMut>,
data: &[u8],
update_mb_state: bool,
) {
let data_len = data.len();
let word_size = core::mem::size_of::<u32>();
let remainder = data_len % word_size;
let n = data_len - remainder;
for idx in (0..n).step_by(word_size) {
mbox.datain()
.write(|_| u32::from_le_bytes(data[idx..idx + word_size].try_into().unwrap()));
}
if remainder > 0 {
let mut last_word = data[n] as u32;
for idx in 1..remainder {
last_word |= (data[n + idx] as u32) << (idx << 3);
}
mbox.datain().write(|_| last_word);
}
if update_mb_state {
mbox.dlen().write(|_| data_len as u32);
mbox.status().write(|w| w.status(|w| w.data_ready()));
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/tools/test-fmc/src/print.rs | rom/dev/tools/test-fmc/src/print.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
pring.rs
Abstract:
File contains support routines and macros to print to UART
--*/
use core::convert::Infallible;
use ufmt::uWrite;
#[derive(Default)]
pub struct RomPrinter;
impl uWrite for RomPrinter {
type Error = Infallible;
/// Writes a string slice into this writer, returning whether the write succeeded.
#[cfg(not(feature = "std"))]
#[inline(never)]
fn write_str(&mut self, _str: &str) -> Result<(), Self::Error> {
#[cfg(feature = "emu")]
caliptra_drivers::Uart::default().write(_str);
Ok(())
}
/// Writes a string slice into this writer, returning whether the write succeeded.
#[cfg(feature = "std")]
fn write_str(&mut self, str: &str) -> Result<(), Self::Error> {
print!("{str}");
Ok(())
}
}
#[macro_export]
macro_rules! cprint {
($($tt:tt)*) => {{
let _ = ufmt::uwrite!(&mut $crate::print::RomPrinter::default(), $($tt)*);
}}
}
#[macro_export]
macro_rules! cprintln {
($($tt:tt)*) => {{
let _ = ufmt::uwriteln!(&mut $crate::print::RomPrinter::default(), $($tt)*);
}}
}
#[macro_export]
macro_rules! cprint_slice {
($name:expr, $arr:expr) => {
$crate::cprint!("{} = ", $name);
for byte in $arr {
$crate::cprint!("{:02X}" byte);
}
$crate::cprintln!("");
}
}
#[macro_export]
macro_rules! cprint_slice_ref {
($name:expr, $arr:expr) => {
$crate::cprint!("{} = ", $name);
for &byte in $arr {
$crate::cprint!("{:02X}" byte);
}
$crate::cprintln!("");
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/exception.rs | rom/dev/src/exception.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
exception.rs
Abstract:
File contains exception related structures
--*/
/// Exception Record
#[repr(C)]
pub(crate) struct ExceptionRecord {
pub ra: u32,
pub sp: u32,
pub a0: u32,
pub a1: u32,
pub a2: u32,
pub a3: u32,
pub a4: u32,
pub a5: u32,
pub a6: u32,
pub a7: u32,
pub t0: u32,
pub t1: u32,
pub t2: u32,
pub t3: u32,
pub t4: u32,
pub t5: u32,
pub t6: u32,
pub mepc: u32,
pub mcause: u32,
pub mscause: u32,
pub mstatus: u32,
pub mtval: u32,
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/rom_env.rs | rom/dev/src/rom_env.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
rom_env.rs
Abstract:
File implements a context holding all the services utilized by ROM.
The primary need for this abstraction is to hide the hardware details
from the ROM flows. The natural side benefit of this abstraction is it
makes authoring mocks and unit tests easy.
--*/
use caliptra_drivers::{
Aes, DeobfuscationEngine, Dma, Ecc384, Hmac, KeyVault, Lms, Mailbox, Mldsa87, PcrBank,
PersistentDataAccessor, Sha1, Sha256, Sha2_512_384, Sha2_512_384Acc, Sha3, SocIfc, Trng,
};
use caliptra_error::CaliptraResult;
use caliptra_registers::{
abr::AbrReg, aes::AesReg, aes_clp::AesClpReg, csrng::CsrngReg, doe::DoeReg, ecc::EccReg,
entropy_src::EntropySrcReg, hmac::HmacReg, kmac::Kmac as KmacReg, kv::KvReg, mbox::MboxCsr,
pv::PvReg, sha256::Sha256Reg, sha512::Sha512Reg, sha512_acc::Sha512AccCsr, soc_ifc::SocIfcReg,
soc_ifc_trng::SocIfcTrngReg,
};
/// Rom Context
pub struct RomEnv {
/// Deobfuscation engine
pub doe: DeobfuscationEngine,
// SHA1 Engine
pub sha1: Sha1,
// SHA2-256 Engine
pub sha256: Sha256,
// SHA2-512/384 Engine
pub sha2_512_384: Sha2_512_384,
// SHA2-512/384 Accelerator
pub sha2_512_384_acc: Sha2_512_384Acc,
// SHA3/SHAKE
pub sha3: Sha3,
/// Hmac Engine
pub hmac: Hmac,
/// Ecc384 Engine
pub ecc384: Ecc384,
/// LMS Engine
pub lms: Lms,
/// Key Vault
pub key_vault: KeyVault,
/// SoC interface
pub soc_ifc: SocIfc,
/// Mailbox
pub mbox: Mailbox,
/// PCR Bank
pub pcr_bank: PcrBank,
/// Cryptographically Secure Random Number Generator
pub trng: Trng,
/// Mechanism to access the persistent data safely
pub persistent_data: PersistentDataAccessor,
/// Mldsa87 Engine
pub mldsa87: Mldsa87,
/// Dma engine
pub dma: Dma,
/// AES engine
pub aes: Aes,
}
impl RomEnv {
pub unsafe fn new_from_registers() -> CaliptraResult<Self> {
let trng = Trng::new(
CsrngReg::new(),
EntropySrcReg::new(),
SocIfcTrngReg::new(),
&SocIfcReg::new(),
)?;
Ok(Self {
doe: DeobfuscationEngine::new(DoeReg::new()),
sha1: Sha1::default(),
sha256: Sha256::new(Sha256Reg::new()),
sha2_512_384: Sha2_512_384::new(Sha512Reg::new()),
sha2_512_384_acc: Sha2_512_384Acc::new(Sha512AccCsr::new()),
sha3: Sha3::new(KmacReg::new()),
hmac: Hmac::new(HmacReg::new()),
ecc384: Ecc384::new(EccReg::new()),
lms: Lms::default(),
key_vault: KeyVault::new(KvReg::new()),
soc_ifc: SocIfc::new(SocIfcReg::new()),
mbox: Mailbox::new(MboxCsr::new()),
pcr_bank: PcrBank::new(PvReg::new()),
trng,
persistent_data: PersistentDataAccessor::new(),
mldsa87: Mldsa87::new(AbrReg::new()),
dma: Dma::default(),
aes: Aes::new(AesReg::new(), AesClpReg::new()),
})
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/lock.rs | rom/dev/src/lock.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
lock.rs
Abstract:
File contains function to lock registers based on reset reason.
--*/
use crate::rom_env::RomEnv;
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_common::{
lock_datavault_region,
pcr::{PCR_ID_FMC_CURRENT, PCR_ID_FMC_JOURNEY, PCR_ID_STASH_MEASUREMENT},
};
use caliptra_drivers::{ColdResetEntries, ResetReason, WarmResetEntries};
use core::mem::size_of;
/// Lock registers
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `reset_reason` - Reset reason
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn lock_registers(env: &mut RomEnv, reset_reason: ResetReason) {
if reset_reason == ResetReason::ColdReset {
lock_cold_reset_reg(env);
lock_common_reg_set(env);
} else {
// For both UpdateReset and WarmReset, we lock the common set of registers.
lock_common_reg_set(env);
}
env.pcr_bank.set_pcr_lock(PCR_ID_FMC_CURRENT);
env.pcr_bank.set_pcr_lock(PCR_ID_FMC_JOURNEY);
env.pcr_bank.set_pcr_lock(PCR_ID_STASH_MEASUREMENT);
env.soc_ifc.set_iccm_lock(true);
}
/// Lock registers on a cold reset
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn lock_cold_reset_reg(env: &mut RomEnv) {
let base_addr = &env
.persistent_data
.get_mut()
.rom
.data_vault
.cold_reset_entries as *const _ as usize;
lock_datavault_region(base_addr, size_of::<ColdResetEntries>(), true);
}
/// Lock all common registers across all reset types
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
fn lock_common_reg_set(env: &mut RomEnv) {
let base_addr = &env
.persistent_data
.get_mut()
.rom
.data_vault
.warm_reset_entries as *const _ as usize;
lock_datavault_region(base_addr, size_of::<WarmResetEntries>(), false);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/wdt.rs | rom/dev/src/wdt.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
wdt.rs
Abstract:
File contains execution routines for programming the Watchdog Timer.
Environment:
ROM
--*/
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_common::WdtTimeout;
use caliptra_drivers::SocIfc;
use crate::cprintln;
/// Start the Watchdog Timer
/// Note: WDT is configured only if the device is in non-debug mode (i.e debug_locked = 1)
///
/// # Arguments
///
/// * `soc_ifc` - SOC Interface
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn start_wdt(soc_ifc: &mut SocIfc) {
if soc_ifc.debug_locked() {
let mut wdt_timeout_cycles = soc_ifc.wdt1_timeout_cycle_count();
if wdt_timeout_cycles == 0 {
wdt_timeout_cycles = 1;
}
cprintln!(
"[state] Starting the WD Timer {} cycles",
wdt_timeout_cycles
);
caliptra_common::wdt::start_wdt(
soc_ifc,
WdtTimeout::from(core::num::NonZeroU64::new(wdt_timeout_cycles).unwrap()),
);
} else {
cprintln!("[state] WD Timer not started. Device not locked for debugging");
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/fuse.rs | rom/dev/src/fuse.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
fuse.rs
Abstract:
The file contains Fuse-related Implementations.
--*/
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_common::{FuseLogEntry, FuseLogEntryId};
use caliptra_drivers::{CaliptraError, CaliptraResult, FuseLogArray};
use zerocopy::IntoBytes;
/// Log Fuse data
///
/// # Arguments
/// * `entry_id` - log entry ID
/// * `data` - data To log to the fuse log
///
/// # Return Value
/// * `Ok(())` - Success
/// * `Err(GlobalErr::FuseLogInvalidEntryId)` - Invalid Fuse log entry ID
/// * `Err(GlobalErr::FuseLogUpsupportedDataLength)` - Unsupported data length
///
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
#[inline(never)]
pub fn log_fuse_data(
log: &mut FuseLogArray,
entry_id: FuseLogEntryId,
data: &[u8],
) -> CaliptraResult<()> {
if entry_id == FuseLogEntryId::Invalid {
return Err(CaliptraError::ROM_GLOBAL_FUSE_LOG_INVALID_ENTRY_ID);
}
// Create a FUSE log entry
let mut log_entry = FuseLogEntry {
entry_id: entry_id as u32,
..Default::default()
};
let Some(data_dest) = log_entry.log_data.as_mut_bytes().get_mut(..data.len()) else {
return Err(CaliptraError::ROM_GLOBAL_FUSE_LOG_UNSUPPORTED_DATA_LENGTH);
};
data_dest.copy_from_slice(data);
// Compiler will optimize out the bounds check because the largest
// FuseLogEntryId is well within the bounds of the array. (double-checked
// via panic_is_possible)
log[entry_id as usize - 1] = log_entry;
Ok(())
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/pcr.rs | rom/dev/src/pcr.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
pcr.rs
Abstract:
File contains execution routines for extending PCR0 & PCR1
Environment:
ROM
Note:
PCR0 - Journey PCR unlocked and cleared on cold reset
PCR1 - Current PCR unlocked and cleared on any reset
--*/
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::{cfi_impl_fn, cfi_mod_fn};
use caliptra_common::{
pcr::{PCR_ID_FMC_CURRENT, PCR_ID_FMC_JOURNEY},
PcrLogEntry, PcrLogEntryId,
};
use caliptra_drivers::{
CaliptraError, CaliptraResult, PcrBank, PersistentData, Sha2_512_384, SocIfc,
};
use caliptra_image_verify::ImageVerificationInfo;
use zerocopy::IntoBytes;
struct PcrExtender<'a> {
persistent_data: &'a mut PersistentData,
pcr_bank: &'a mut PcrBank,
sha2_512_384: &'a mut Sha2_512_384,
}
impl PcrExtender<'_> {
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
#[inline(never)]
fn extend(&mut self, data: &[u8], pcr_entry_id: PcrLogEntryId) -> CaliptraResult<()> {
self.pcr_bank
.extend_pcr(PCR_ID_FMC_CURRENT, self.sha2_512_384, data)?;
self.pcr_bank
.extend_pcr(PCR_ID_FMC_JOURNEY, self.sha2_512_384, data)?;
let pcr_ids: u32 = (1 << PCR_ID_FMC_CURRENT as u8) | (1 << PCR_ID_FMC_JOURNEY as u8);
log_pcr(self.persistent_data, pcr_entry_id, pcr_ids, data)
}
}
/// Extend PCR0 and PCR1
///
/// # Arguments
///
/// * `persistent_data` - Persistent data
/// * `soc_ifc` - SOC Interface
/// * `pcr_bank` - PCR Bank
/// * `sha2_512_384` - SHA-512/384 Accelerator
/// * `info` - Image Verification Info
///
/// # Return Value
/// * `Ok(())` on success, error code on failure
///
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
#[inline(never)]
pub(crate) fn extend_pcrs(
persistent_data: &mut PersistentData,
soc_ifc: &SocIfc,
pcr_bank: &mut PcrBank,
sha2_512_384: &mut Sha2_512_384,
info: &ImageVerificationInfo,
) -> CaliptraResult<()> {
let data_vault = &persistent_data.rom.data_vault;
let owner_pk_hash = <[u8; 48]>::from(&data_vault.owner_pk_hash());
let fmc_tci = <[u8; 48]>::from(&data_vault.fmc_tci());
// Reset the PCR log size to zero.
persistent_data.rom.fht.pcr_log_index = 0;
// Clear the Current PCR, but do not clear the Journey PCR
pcr_bank.erase_pcr(PCR_ID_FMC_CURRENT)?;
let device_status: [u8; 9] = [
soc_ifc.lifecycle() as u8,
soc_ifc.debug_locked() as u8,
soc_ifc.fuse_bank().anti_rollback_disable() as u8,
data_vault.vendor_ecc_pk_index() as u8,
data_vault.cold_boot_fw_svn() as u8,
info.effective_fuse_svn as u8,
data_vault.vendor_pqc_pk_index() as u8,
info.pqc_key_type as u8,
info.owner_pub_keys_digest_in_fuses as u8,
];
let mut pcr = PcrExtender {
persistent_data,
pcr_bank,
sha2_512_384,
};
pcr.extend(&device_status, PcrLogEntryId::DeviceStatus)?;
pcr.extend(
&<[u8; 48]>::from(&soc_ifc.fuse_bank().vendor_pub_key_info_hash()),
PcrLogEntryId::VendorPubKeyInfoHash,
)?;
pcr.extend(&owner_pk_hash, PcrLogEntryId::OwnerPubKeyHash)?;
pcr.extend(&fmc_tci, PcrLogEntryId::FmcTci)?;
Ok(())
}
/// Log PCR data
///
/// # Arguments
/// * `pcr_bank` - PCR bank
/// * `pcr_entry_id` - PCR log entry ID
/// * `pcr_ids` - bitmask of PCR indices
/// * `data` - PCR data
///
/// # Return Value
/// * `Ok(())` - Success
/// * `Err(GlobalErr::PcrLogInvalidEntryId)` - Invalid PCR log entry ID
/// * `Err(GlobalErr::PcrLogUpsupportedDataLength)` - Unsupported data length
///
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn log_pcr(
persistent_data: &mut PersistentData,
pcr_entry_id: PcrLogEntryId,
pcr_ids: u32,
data: &[u8],
) -> CaliptraResult<()> {
if pcr_entry_id == PcrLogEntryId::Invalid {
return Err(CaliptraError::ROM_GLOBAL_PCR_LOG_INVALID_ENTRY_ID);
}
let pcr_log = &mut persistent_data.rom.pcr_log;
let fht = &mut persistent_data.rom.fht;
let Some(dst) = pcr_log.get_mut(fht.pcr_log_index as usize) else {
return Err(CaliptraError::ROM_GLOBAL_PCR_LOG_EXHAUSTED);
};
// Create a PCR log entry
let mut pcr_log_entry = PcrLogEntry {
id: pcr_entry_id as u16,
pcr_ids,
..Default::default()
};
let Some(dest_data) = pcr_log_entry.pcr_data.as_mut_bytes().get_mut(..data.len()) else {
return Err(CaliptraError::ROM_GLOBAL_PCR_LOG_UNSUPPORTED_DATA_LENGTH);
};
dest_data.copy_from_slice(data);
fht.pcr_log_index += 1;
*dst = pcr_log_entry;
Ok(())
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/main.rs | rom/dev/src/main.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
main.rs
Abstract:
File contains main entry point for Caliptra ROM
--*/
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(not(feature = "std"), no_main)]
#![cfg_attr(feature = "fake-rom", allow(unused_imports))]
#![cfg_attr(feature = "fips-test-hooks", allow(dead_code))]
use crate::{lock::lock_registers, print::HexBytes};
use caliptra_cfi_lib::{cfi_assert_eq, CfiCounter};
use caliptra_common::RomBootStatus::{KatComplete, KatStarted};
use caliptra_common::{handle_fatal_error, RomBootStatus};
use caliptra_kat::*;
use caliptra_registers::soc_ifc::SocIfcReg;
use core::hint::black_box;
use crate::lock::lock_cold_reset_reg;
use caliptra_drivers::{
cprintln, report_boot_status, report_fw_error_non_fatal, CaliptraError, ResetReason,
ShaAccLockState, Trng,
};
use caliptra_error::CaliptraResult;
use caliptra_image_types::RomInfo;
use caliptra_kat::KatsEnv;
use rom_env::RomEnv;
use zeroize::Zeroize;
#[cfg(not(feature = "std"))]
core::arch::global_asm!(include_str!(concat!(
env!("OUT_DIR"),
"/start_preprocessed.S"
)));
mod crypto;
mod exception;
mod fht;
mod flow;
mod fuse;
mod key_ladder;
mod lock;
mod pcr;
mod rom_env;
mod wdt;
use caliptra_drivers::printer as print;
#[cfg(feature = "std")]
pub fn main() {}
const BANNER: &str = r#"
Running Caliptra ROM ...
"#;
extern "C" {
static CALIPTRA_ROM_INFO: RomInfo;
}
#[no_mangle]
pub extern "C" fn rom_entry() -> ! {
cprintln!("{}", BANNER);
let mut env = match unsafe { rom_env::RomEnv::new_from_registers() } {
Ok(env) => env,
Err(e) => handle_fatal_error(e.into()),
};
if !cfg!(feature = "no-cfi") {
let mut entropy_gen = || env.trng.generate4();
CfiCounter::reset(&mut entropy_gen);
CfiCounter::reset(&mut entropy_gen);
CfiCounter::reset(&mut entropy_gen);
}
// Check if TRNG is correctly sourced as per hw config.
validate_trng_config(&mut env);
report_boot_status(RomBootStatus::CfiInitialized.into());
let reset_reason = env.soc_ifc.reset_reason();
// Lock the Cold Reset registers since they need to remain locked on an Update or Warm reset.
if reset_reason != ResetReason::ColdReset {
lock_cold_reset_reg(&mut env);
}
let lifecyle = match env.soc_ifc.lifecycle() {
caliptra_drivers::Lifecycle::Unprovisioned => "Unprovisioned",
caliptra_drivers::Lifecycle::Manufacturing => "Manufacturing",
caliptra_drivers::Lifecycle::Production => "Production",
caliptra_drivers::Lifecycle::Reserved2 => "Unknown",
};
cprintln!("[state] LifecycleState = {}", lifecyle);
if let Err(err) = crate::flow::debug_unlock::debug_unlock(&mut env) {
handle_fatal_error(err.into());
}
// UDS programming.
if let Err(err) = crate::flow::UdsProgrammingFlow::program_uds(&mut env) {
handle_fatal_error(err.into());
}
if cfg!(feature = "fake-rom")
&& (env.soc_ifc.lifecycle() == caliptra_drivers::Lifecycle::Production)
&& !(env.soc_ifc.prod_en_in_fake_mode())
{
handle_fatal_error(CaliptraError::ROM_GLOBAL_FAKE_ROM_IN_PRODUCTION.into());
}
cprintln!(
"[state] DebugLocked = {}",
if env.soc_ifc.debug_locked() {
"Yes"
} else {
"No"
}
);
if env.soc_ifc.ocp_lock_enabled() {
cprintln!("[ROM] OCP-LOCK Supported");
}
// Set the ROM version
let rom_info = unsafe { &CALIPTRA_ROM_INFO };
if !cfg!(feature = "fake-rom") {
env.soc_ifc.set_rom_fw_rev_id(rom_info.version);
} else {
env.soc_ifc.set_rom_fw_rev_id(0xFFFF);
}
// Start the watchdog timer
wdt::start_wdt(&mut env.soc_ifc);
if !cfg!(feature = "fake-rom") {
let mut kats_env = caliptra_kat::KatsEnv {
// SHA1 Engine
sha1: &mut env.sha1,
// sha256
sha256: &mut env.sha256,
// SHA2-512/384 Engine
sha2_512_384: &mut env.sha2_512_384,
// SHA2-512/384 Accelerator
sha2_512_384_acc: &mut env.sha2_512_384_acc,
// SHA3/SHAKE
sha3: &mut env.sha3,
// Hmac-512/384 Engine
hmac: &mut env.hmac,
// Cryptographically Secure Random Number Generator
trng: &mut env.trng,
// LMS Engine
lms: &mut env.lms,
// MLDSA87 Engine
mldsa87: &mut env.mldsa87,
// Ecc384 Engine
ecc384: &mut env.ecc384,
// AES Engine
aes: &mut env.aes,
// SHA Acc lock state.
// SHA Acc is guaranteed to be locked on Cold and Warm Resets;
// On an Update Reset, it is expected to be unlocked.
// Not having it unlocked will result in a fatal error.
sha_acc_lock_state: if reset_reason == ResetReason::UpdateReset {
ShaAccLockState::NotAcquired
} else {
ShaAccLockState::AssumedLocked
},
};
let result = run_fips_tests(&mut kats_env);
if let Err(err) = result {
handle_fatal_error(err.into());
}
}
if let Err(err) = flow::run(&mut env) {
//
// For the update reset case, when we fail the image validation
// we will need to continue to jump to the FMC after
// reporting the error in the registers.
//
if reset_reason == ResetReason::UpdateReset {
handle_non_fatal_error(err.into());
} else {
handle_fatal_error(err.into());
}
}
// Lock the datavault registers.
lock_registers(&mut env, reset_reason);
// Reset the CFI counter.
if !cfg!(feature = "no-cfi") {
CfiCounter::corrupt();
}
// FIPS test hooks mode does not allow handoff to FMC to prevent incorrect/accidental usage
#[cfg(feature = "fips-test-hooks")]
handle_fatal_error(CaliptraError::ROM_GLOBAL_FIPS_HOOKS_ROM_EXIT.into());
#[cfg(not(any(feature = "no-fmc", feature = "fips-test-hooks")))]
launch_fmc(&mut env);
#[cfg(feature = "no-fmc")]
caliptra_drivers::ExitCtrl::exit(0);
}
fn run_fips_tests(env: &mut KatsEnv) -> CaliptraResult<()> {
report_boot_status(KatStarted.into());
cprintln!("[kat] SHA2-256");
Sha256Kat::default().execute(env.sha256)?;
#[cfg(feature = "fips-test-hooks")]
unsafe {
caliptra_drivers::FipsTestHook::halt_if_hook_set(
caliptra_drivers::FipsTestHook::HALT_SELF_TESTS,
)
};
// ROM integrity check needs SHA2-256 KAT to be executed first per FIPS requirement AS10.20.
let rom_info = unsafe { &CALIPTRA_ROM_INFO };
rom_integrity_test(env, &rom_info.sha256_digest)?;
caliptra_kat::execute_kat(env)?;
report_boot_status(KatComplete.into());
Ok(())
}
fn rom_integrity_test(env: &mut KatsEnv, expected_digest: &[u32; 8]) -> CaliptraResult<()> {
// WARNING: It is undefined behavior to dereference a zero (null) pointer in
// rust code. This is only safe because the dereference is being done by an
// an assembly routine ([`ureg::opt_riscv::copy_16_words`]) rather
// than dereferencing directly in Rust.
#[allow(clippy::zero_ptr)]
let rom_start = 0 as *const [u32; 16];
let n_blocks = unsafe { &CALIPTRA_ROM_INFO as *const RomInfo as usize / 64 };
let mut digest = unsafe { env.sha256.digest_blocks_raw(rom_start, n_blocks)? };
cprintln!("ROM Digest: {}", HexBytes(&<[u8; 32]>::from(digest)));
if digest.0 != *expected_digest {
digest.zeroize();
return Err(CaliptraError::ROM_INTEGRITY_FAILURE);
}
digest.zeroize();
Ok(())
}
fn launch_fmc(env: &mut RomEnv) -> ! {
// Function is defined in start.S
extern "C" {
fn exit_rom(entry: u32) -> !;
}
// Get the fmc entry point from data vault
let entry = env.persistent_data.get().rom.data_vault.fmc_entry_point();
cprintln!("[exit] Launching FMC @ 0x{:08X}", entry);
// Exit ROM and jump to specified entry point
unsafe { exit_rom(entry) }
}
#[no_mangle]
#[inline(never)]
extern "C" fn exception_handler(exception: &exception::ExceptionRecord) {
cprintln!(
"EXCEPTION mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X} ra=0x{:08X}",
exception.mcause,
exception.mscause,
exception.mepc,
exception.ra
);
{
let mut soc_ifc = unsafe { SocIfcReg::new() };
let soc_ifc = soc_ifc.regs_mut();
let ext_info = soc_ifc.cptra_fw_extended_error_info();
ext_info.at(0).write(|_| exception.mcause);
ext_info.at(1).write(|_| exception.mscause);
ext_info.at(2).write(|_| exception.mepc);
ext_info.at(3).write(|_| exception.ra);
}
handle_fatal_error(CaliptraError::ROM_GLOBAL_EXCEPTION.into());
}
#[no_mangle]
#[inline(never)]
extern "C" fn nmi_handler(exception: &exception::ExceptionRecord) {
let mut soc_ifc = unsafe { SocIfcReg::new() };
// If the NMI was fired by caliptra instead of the uC, this register
// contains the reason(s)
let err_interrupt_status = u32::from(
soc_ifc
.regs()
.intr_block_rf()
.error_internal_intr_r()
.read(),
);
cprintln!(
"NMI mcause=0x{:08X} mscause=0x{:08X} mepc=0x{:08X} ra=0x{:08X} error_internal_intr_r={:08X}",
exception.mcause,
exception.mscause,
exception.mepc,
exception.ra,
err_interrupt_status,
);
{
let soc_ifc = soc_ifc.regs_mut();
let ext_info = soc_ifc.cptra_fw_extended_error_info();
ext_info.at(0).write(|_| exception.mcause);
ext_info.at(1).write(|_| exception.mscause);
ext_info.at(2).write(|_| exception.mepc);
ext_info.at(3).write(|_| exception.ra);
ext_info.at(4).write(|_| err_interrupt_status);
}
// Check if the NMI was due to WDT expiry.
let mut error = CaliptraError::ROM_GLOBAL_NMI;
let wdt_status = soc_ifc.regs().cptra_wdt_status().read();
if wdt_status.t1_timeout() || wdt_status.t2_timeout() {
error = CaliptraError::ROM_GLOBAL_WDT_EXPIRED;
}
handle_fatal_error(error.into());
}
#[panic_handler]
#[inline(never)]
#[cfg(not(feature = "std"))]
fn rom_panic(_: &core::panic::PanicInfo) -> ! {
cprintln!("Panic!!");
panic_is_possible();
handle_fatal_error(CaliptraError::ROM_GLOBAL_PANIC.into());
}
fn handle_non_fatal_error(code: u32) {
cprintln!("ROM Non-Fatal Error: 0x{:08X}", code);
report_fw_error_non_fatal(code);
}
#[no_mangle]
extern "C" fn cfi_panic_handler(code: u32) -> ! {
cprintln!("[ROM] CFI Panic");
handle_fatal_error(code);
}
#[no_mangle]
#[inline(never)]
fn panic_is_possible() {
black_box(());
// The existence of this symbol is used to inform test_panic_missing
// that panics are possible. Do not remove or rename this symbol.
}
#[inline(always)]
fn validate_trng_config(env: &mut RomEnv) {
// NOTE: The usage of non-short-circuiting boolean operations (| and &) is
// explicit here, and necessary to prevent the compiler from inserting a ton
// of glitch-susceptible jumps into the generated code.
cfi_assert_eq(
env.soc_ifc.hw_config_internal_trng()
& (!env.soc_ifc.mfg_flag_rng_unavailable() | env.soc_ifc.debug_locked()),
matches!(env.trng, Trng::Internal(_)),
);
cfi_assert_eq(
!env.soc_ifc.hw_config_internal_trng()
& (!env.soc_ifc.mfg_flag_rng_unavailable() | env.soc_ifc.debug_locked()),
matches!(env.trng, Trng::External(_)),
);
cfi_assert_eq(
env.soc_ifc.mfg_flag_rng_unavailable() & !env.soc_ifc.debug_locked(),
matches!(env.trng, Trng::MfgMode()),
);
cfi_assert_eq(
env.soc_ifc.hw_config_internal_trng()
& (!env.soc_ifc.mfg_flag_rng_unavailable() | env.soc_ifc.debug_locked()),
matches!(env.trng, Trng::Internal(_)),
);
cfi_assert_eq(
!env.soc_ifc.hw_config_internal_trng()
& (!env.soc_ifc.mfg_flag_rng_unavailable() | env.soc_ifc.debug_locked()),
matches!(env.trng, Trng::External(_)),
);
cfi_assert_eq(
env.soc_ifc.mfg_flag_rng_unavailable() & !env.soc_ifc.debug_locked(),
matches!(env.trng, Trng::MfgMode()),
);
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/key_ladder.rs | rom/dev/src/key_ladder.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
key_ladder.rs
Abstract:
File contains function to manage the firmware's key ladder.
--*/
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_cfi_lib::cfi_assert_eq;
use caliptra_common::crypto::Crypto;
use caliptra_common::keyids::{KEY_ID_FW_KEY_LADDER, KEY_ID_ROM_FMC_CDI};
use caliptra_drivers::{Hmac, HmacMode, KeyId, KeyUsage, Trng};
use caliptra_error::CaliptraResult;
use crate::rom_env::RomEnv;
// This KeyId only holds the LDevID CDI during a specific phase of cold-boot: after
// the LDevID has been derived, but before firmware has been verified and executed.
const LDEVID_CDI: KeyId = KEY_ID_ROM_FMC_CDI;
const LADDER_KEY: KeyId = KEY_ID_FW_KEY_LADDER;
/// Initialize key ladder on cold reset, bound to the lifecycle and debug states.
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `ladder_len` - Length of ladder to initialize, based on firmware's SVN
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub(crate) fn initialize_key_ladder(env: &mut RomEnv, ladder_len: u32) -> CaliptraResult<()> {
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
LDEVID_CDI,
b"si_init",
Some(&[
env.soc_ifc.lifecycle() as u8,
env.soc_ifc.debug_locked() as u8,
]),
LADDER_KEY,
HmacMode::Hmac512,
KeyUsage::default().set_hmac_key_en(),
)?;
extend_key_ladder(&mut env.hmac, &mut env.trng, ladder_len)
}
/// Extend key ladder, on cold or update reset.
///
/// # Arguments
///
/// * `hmac` - HMAC helper
/// * `trng` - TRNG helper
/// * `num_iters` - Amount by which to extend the ladder
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub(crate) fn extend_key_ladder(
hmac: &mut Hmac,
trng: &mut Trng,
num_iters: u32,
) -> CaliptraResult<()> {
let mut i: u32 = 0;
for _ in 0..num_iters {
i += 1;
Crypto::hmac_kdf(
hmac,
trng,
LADDER_KEY,
b"si_extend",
None,
LADDER_KEY,
HmacMode::Hmac512,
KeyUsage::default().set_hmac_key_en(),
)?;
}
cfi_assert_eq(num_iters, i);
Ok(())
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/crypto.rs | rom/dev/src/crypto.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
crypto.rs
Abstract:
Crypto helper routines
--*/
use caliptra_drivers::Ecc384Signature;
use caliptra_x509::Ecdsa384Signature;
/// ECDSA-384 Signature Adapter
///
pub trait Ecdsa384SignatureAdapter {
/// Convert to ECDSA Signature
fn to_ecdsa(&self) -> Ecdsa384Signature;
}
impl Ecdsa384SignatureAdapter for Ecc384Signature {
/// Convert to ECDSA Signatuure
fn to_ecdsa(&self) -> Ecdsa384Signature {
Ecdsa384Signature {
r: (&self.r).into(),
s: (&self.s).into(),
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/fht.rs | rom/dev/src/fht.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
fht.rs
Abstract:
Firmware Handoff table creation and loading.
--*/
use crate::{rom_env::RomEnv, CALIPTRA_ROM_INFO};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_common::{
keyids::{
KEY_ID_FMC_ECDSA_PRIV_KEY, KEY_ID_FMC_MLDSA_KEYPAIR_SEED, KEY_ID_FW_KEY_LADDER,
KEY_ID_ROM_FMC_CDI,
},
FirmwareHandoffTable, HandOffDataHandle, Vault, FHT_INVALID_HANDLE, FHT_MARKER,
};
use caliptra_drivers::RomAddr;
use caliptra_image_verify::MAX_FIRMWARE_SVN;
const FHT_MAJOR_VERSION: u16 = 1;
const FHT_MINOR_VERSION: u16 = 0;
#[derive(Debug, Default)]
pub struct FhtDataStore {}
impl FhtDataStore {
/// The FMC CDI is stored in a Key Vault slot.
pub const fn fmc_cdi_store() -> HandOffDataHandle {
HandOffDataHandle(((Vault::KeyVault as u32) << 12) | KEY_ID_ROM_FMC_CDI as u32)
}
/// The FMC ECC private key is stored in a Key Vault slot.
pub const fn fmc_ecc_priv_key_store() -> HandOffDataHandle {
HandOffDataHandle(((Vault::KeyVault as u32) << 12) | KEY_ID_FMC_ECDSA_PRIV_KEY as u32)
}
/// The FMC MLDSA key pair seed is stored in a Key Vault slot.
pub const fn fmc_mldsa_keypair_seed_store() -> HandOffDataHandle {
HandOffDataHandle(((Vault::KeyVault as u32) << 12) | KEY_ID_FMC_MLDSA_KEYPAIR_SEED as u32)
}
/// The firmware key ladder is stored in a KeyVault slot.
pub const fn fw_key_ladder_store() -> HandOffDataHandle {
HandOffDataHandle(((Vault::KeyVault as u32) << 12) | KEY_ID_FW_KEY_LADDER as u32)
}
}
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn initialize_fht(env: &mut RomEnv) {
let pdata = &env.persistent_data.get();
env.persistent_data.get_mut().rom.fht = FirmwareHandoffTable {
fht_marker: FHT_MARKER,
fht_major_ver: FHT_MAJOR_VERSION,
fht_minor_ver: FHT_MINOR_VERSION,
fips_fw_load_addr_hdl: FHT_INVALID_HANDLE,
fmc_cdi_kv_hdl: FhtDataStore::fmc_cdi_store(),
fmc_ecc_priv_key_kv_hdl: FhtDataStore::fmc_ecc_priv_key_store(),
fmc_mldsa_keypair_seed_kv_hdl: FhtDataStore::fmc_mldsa_keypair_seed_store(),
rt_cdi_kv_hdl: FHT_INVALID_HANDLE,
rt_priv_key_kv_hdl: FHT_INVALID_HANDLE,
rom_info_addr: RomAddr::from(unsafe { &CALIPTRA_ROM_INFO }),
manifest_load_addr: &pdata.rom.manifest1 as *const _ as u32,
ecc_ldevid_tbs_addr: &pdata.rom.ecc_ldevid_tbs as *const _ as u32,
ecc_fmcalias_tbs_addr: &pdata.rom.ecc_fmcalias_tbs as *const _ as u32,
mldsa_ldevid_tbs_addr: &pdata.rom.mldsa_ldevid_tbs as *const _ as u32,
mldsa_fmcalias_tbs_addr: &pdata.rom.mldsa_fmcalias_tbs as *const _ as u32,
pcr_log_addr: &pdata.rom.pcr_log as *const _ as u32,
meas_log_addr: &pdata.rom.measurement_log as *const _ as u32,
fuse_log_addr: &pdata.rom.fuse_log as *const _ as u32,
fw_key_ladder_max_svn: MAX_FIRMWARE_SVN as u16,
fw_key_ladder_kv_hdl: FhtDataStore::fw_key_ladder_store(),
..Default::default()
};
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/fake.rs | rom/dev/src/flow/fake.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
fake.rs
Abstract:
File contains the implementation of the fake ROM reset flows
--*/
#[cfg(not(feature = "fake-rom"))]
compile_error!("This file should NEVER be included except for the fake-rom feature");
use crate::fht;
use crate::flow::cold_reset::fw_processor::FirmwareProcessor;
use crate::flow::update_reset;
use crate::flow::warm_reset;
use crate::print::HexBytes;
use crate::rom_env::RomEnv;
use caliptra_common::keyids::KEY_ID_ROM_FMC_CDI;
use caliptra_common::FirmwareHandoffTable;
use caliptra_common::RomBootStatus::*;
use caliptra_drivers::cprintln;
use caliptra_drivers::Lifecycle;
use caliptra_drivers::LmsResult;
use caliptra_drivers::VendorEccPubKeyRevocation;
use caliptra_drivers::*;
use caliptra_error::CaliptraError;
use caliptra_image_types::*;
use caliptra_image_verify::ImageVerificationEnv;
use caliptra_registers::sha512_acc::Sha512AccCsr;
use core::ops::Range;
include!(concat!(env!("OUT_DIR"), "/fake_consts.rs"));
pub struct FakeRomFlow {}
impl FakeRomFlow {
/// Execute ROM Flows based on reset reason
///
/// # Arguments
///
/// * `env` - ROM Environment
#[inline(never)]
pub fn run(env: &mut RomEnv) -> CaliptraResult<()> {
let reset_reason = env.soc_ifc.reset_reason();
match reset_reason {
// Cold Reset Flow
ResetReason::ColdReset => {
cprintln!("[fake-rom-cold-reset] ++");
report_boot_status(ColdResetStarted.into());
env.persistent_data.get_mut().rom.marker = RomPersistentData::MAGIC;
env.persistent_data.get_mut().rom.major_version = RomPersistentData::MAJOR_VERSION;
env.persistent_data.get_mut().rom.minor_version = RomPersistentData::MINOR_VERSION;
// Zeroize the key vault in the fake ROM flow
unsafe { KeyVault::zeroize() };
env.soc_ifc.flow_status_set_ready_for_mb_processing();
fht::initialize_fht(env);
// SKIP Execute IDEVID layer
// LDEVID cert
copy_canned_ldev_cert(env)?;
// LDEVID cdi
initialize_fake_ldevid_cdi(env)?;
// Unlock the SHA Acc by creating a SHA Acc operation and dropping it.
// In real ROM, this is done as part of executing the SHA-ACC KAT.
let sha_op = env
.sha2_512_384_acc
.try_start_operation(ShaAccLockState::AssumedLocked)
.unwrap();
drop(sha_op);
// Download and validate firmware.
_ = FirmwareProcessor::process(env)?;
// FMC Alias Cert
copy_canned_fmc_alias_cert(env)?;
cprintln!("[fake-rom-cold-reset] --");
report_boot_status(ColdResetComplete.into());
Ok(())
}
// Warm Reset Flow
ResetReason::WarmReset => warm_reset::WarmResetFlow::run(env),
// Update Reset Flow
ResetReason::UpdateReset => update_reset::UpdateResetFlow::run(env),
// Unknown/Spurious Reset Flow
ResetReason::Unknown => Err(CaliptraError::ROM_UNKNOWN_RESET_FLOW),
}
}
}
// Used to derive the firmware's key ladder.
fn initialize_fake_ldevid_cdi(env: &mut RomEnv) -> CaliptraResult<()> {
let fake_key = Array4x16::from([0x1234_5678u32; 16]);
env.hmac.hmac(
HmacKey::Array4x16(&fake_key),
HmacData::Slice(b""),
&mut env.trng,
KeyWriteArgs::new(KEY_ID_ROM_FMC_CDI, KeyUsage::default().set_hmac_key_en()).into(),
HmacMode::Hmac512,
)
}
pub fn copy_canned_ldev_cert(env: &mut RomEnv) -> CaliptraResult<()> {
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Store signature
data_vault.set_ldev_dice_ecc_signature(&FAKE_LDEV_ECC_SIG);
data_vault.set_ldev_dice_mldsa_signature(&LEArray4x1157::from(&FAKE_LDEV_MLDSA_SIG));
// Store pub key
data_vault.set_ldev_dice_ecc_pub_key(&FAKE_LDEV_ECC_PUB_KEY);
data_vault.set_ldev_dice_mldsa_pub_key(&LEArray4x648::from(&FAKE_LDEV_MLDSA_PUB_KEY));
// Copy TBS to DCCM
let tbs = &FAKE_LDEV_ECC_TBS;
env.persistent_data.get_mut().rom.fht.ecc_ldevid_tbs_size = u16::try_from(tbs.len()).unwrap();
let Some(dst) = env
.persistent_data
.get_mut()
.rom
.ecc_ldevid_tbs
.get_mut(..tbs.len())
else {
return Err(CaliptraError::ROM_GLOBAL_UNSUPPORTED_LDEVID_TBS_SIZE);
};
dst.copy_from_slice(tbs);
let tbs = &FAKE_LDEV_MLDSA_TBS;
env.persistent_data.get_mut().rom.fht.mldsa_ldevid_tbs_size = u16::try_from(tbs.len()).unwrap();
let Some(dst) = env
.persistent_data
.get_mut()
.rom
.mldsa_ldevid_tbs
.get_mut(..tbs.len())
else {
return Err(CaliptraError::ROM_GLOBAL_UNSUPPORTED_LDEVID_TBS_SIZE);
};
dst.copy_from_slice(tbs);
Ok(())
}
pub fn copy_canned_fmc_alias_cert(env: &mut RomEnv) -> CaliptraResult<()> {
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Store signature
data_vault.set_fmc_dice_ecc_signature(&FAKE_FMC_ALIAS_ECC_SIG);
data_vault.set_fmc_dice_mldsa_signature(&LEArray4x1157::from(&FAKE_FMC_ALIAS_MLDSA_SIG));
// Store pub key
data_vault.set_fmc_ecc_pub_key(&FAKE_FMC_ALIAS_ECC_PUB_KEY);
data_vault.set_fmc_mldsa_pub_key(&LEArray4x648::from(&FAKE_FMC_ALIAS_MLDSA_PUB_KEY));
// Copy TBS to DCCM
let tbs = &FAKE_FMC_ALIAS_ECC_TBS;
env.persistent_data.get_mut().rom.fht.ecc_fmcalias_tbs_size = u16::try_from(tbs.len()).unwrap();
let Some(dst) = env
.persistent_data
.get_mut()
.rom
.ecc_fmcalias_tbs
.get_mut(..tbs.len())
else {
return Err(CaliptraError::ROM_GLOBAL_UNSUPPORTED_FMCALIAS_TBS_SIZE);
};
dst.copy_from_slice(tbs);
let tbs = &FAKE_FMC_ALIAS_MLDSA_TBS;
env.persistent_data
.get_mut()
.rom
.fht
.mldsa_fmcalias_tbs_size = u16::try_from(tbs.len()).unwrap();
let Some(dst) = env
.persistent_data
.get_mut()
.rom
.mldsa_fmcalias_tbs
.get_mut(..tbs.len())
else {
return Err(CaliptraError::ROM_GLOBAL_UNSUPPORTED_FMCALIAS_TBS_SIZE);
};
dst.copy_from_slice(tbs);
Ok(())
}
/// Image source for verification
pub enum ImageSource<'a, 'b> {
/// Image is in memory (accessible as a byte slice)
Memory(&'b [u8]),
/// Image is in MCU SRAM (requires DMA access)
McuSram(&'a Dma),
}
// ROM Verification Environment
pub(crate) struct FakeRomImageVerificationEnv<'a, 'b> {
pub(crate) sha256: &'a mut Sha256,
pub(crate) sha2_512_384: &'a mut Sha2_512_384,
pub(crate) sha2_512_384_acc: &'a mut Sha2_512_384Acc,
pub(crate) soc_ifc: &'a mut SocIfc,
pub(crate) data_vault: &'a DataVault,
pub(crate) ecc384: &'a mut Ecc384,
pub(crate) mldsa87: &'a mut Mldsa87,
pub image_source: ImageSource<'a, 'b>,
}
impl FakeRomImageVerificationEnv<'_, '_> {
fn create_dma_recovery<'a>(soc_ifc: &'a SocIfc, dma: &'a Dma) -> DmaRecovery<'a> {
DmaRecovery::new(
soc_ifc.recovery_interface_base_addr().into(),
soc_ifc.caliptra_base_axi_addr().into(),
soc_ifc.mci_base_addr().into(),
dma,
)
}
}
impl ImageVerificationEnv for &mut FakeRomImageVerificationEnv<'_, '_> {
/// Calculate 384 digest using SHA2 Engine
fn sha384_digest(&mut self, offset: u32, len: u32) -> CaliptraResult<ImageDigest384> {
let err = CaliptraError::IMAGE_VERIFIER_ERR_DIGEST_OUT_OF_BOUNDS;
match &self.image_source {
ImageSource::McuSram(dma) => {
let dma_recovery =
FakeRomImageVerificationEnv::create_dma_recovery(self.soc_ifc, dma);
let result = dma_recovery.sha384_mcu_sram(
self.sha2_512_384_acc,
offset,
len,
dma::AesDmaMode::None,
)?;
Ok(result.into())
}
ImageSource::Memory(image) => {
let data = image
.get(offset as usize..)
.ok_or(err)?
.get(..len as usize)
.ok_or(err)?;
Ok(self.sha2_512_384.sha384_digest(data)?.0)
}
}
}
/// Calculate 512 digest using SHA2 Engine
fn sha512_digest(&mut self, offset: u32, len: u32) -> CaliptraResult<ImageDigest512> {
let err = CaliptraError::IMAGE_VERIFIER_ERR_DIGEST_OUT_OF_BOUNDS;
match &self.image_source {
ImageSource::McuSram(dma) => {
let dma_recovery =
FakeRomImageVerificationEnv::create_dma_recovery(self.soc_ifc, dma);
let result = dma_recovery.sha512_mcu_sram(
self.sha2_512_384_acc,
offset,
len,
AesDmaMode::None,
)?;
Ok(result.into())
}
ImageSource::Memory(image) => {
let data = image
.get(offset as usize..)
.ok_or(err)?
.get(..len as usize)
.ok_or(err)?;
Ok(self.sha2_512_384.sha512_digest(data)?.0)
}
}
}
fn sha384_acc_digest(
&mut self,
offset: u32,
len: u32,
digest_failure: CaliptraError,
) -> CaliptraResult<ImageDigest384> {
match &self.image_source {
ImageSource::McuSram(_) => {
// For MCU case, use the existing sha384_digest function
self.sha384_digest(offset, len).map_err(|_| digest_failure)
}
ImageSource::Memory(_) => {
let mut digest = Array4x12::default();
if let Some(mut sha_acc_op) = self
.sha2_512_384_acc
.try_start_operation(ShaAccLockState::NotAcquired)?
{
sha_acc_op
.digest_384(len, offset, StreamEndianness::Reorder, &mut digest)
.map_err(|_| digest_failure)?;
} else {
Err(CaliptraError::KAT_SHA2_512_384_ACC_DIGEST_START_OP_FAILURE)?;
};
Ok(digest.0)
}
}
}
fn sha512_acc_digest(
&mut self,
offset: u32,
len: u32,
digest_failure: CaliptraError,
) -> CaliptraResult<ImageDigest512> {
match &self.image_source {
ImageSource::McuSram(_) => {
// For MCU case, use the existing sha512_digest function
self.sha512_digest(offset, len).map_err(|_| digest_failure)
}
ImageSource::Memory(_) => {
let mut digest = Array4x16::default();
if let Some(mut sha_acc_op) = self
.sha2_512_384_acc
.try_start_operation(ShaAccLockState::NotAcquired)?
{
sha_acc_op
.digest_512(len, offset, StreamEndianness::Reorder, &mut digest)
.map_err(|_| digest_failure)?;
} else {
Err(CaliptraError::KAT_SHA2_512_384_ACC_DIGEST_START_OP_FAILURE)?;
};
Ok(digest.0)
}
}
}
/// ECC-384 Verification routine
fn ecc384_verify(
&mut self,
digest: &ImageDigest384,
pub_key: &ImageEccPubKey,
sig: &ImageEccSignature,
) -> CaliptraResult<Array4xN<12, 48>> {
if self.soc_ifc.verify_in_fake_mode() {
let pub_key = Ecc384PubKey {
x: pub_key.x.into(),
y: pub_key.y.into(),
};
let digest: Array4x12 = digest.into();
let sig = Ecc384Signature {
r: sig.r.into(),
s: sig.s.into(),
};
self.ecc384.verify_r(&pub_key, &digest, &sig)
} else {
// Mock verify, just always return success
Ok(Array4x12::from(sig.r))
}
}
fn lms_verify(
&mut self,
digest: &ImageDigest384,
pub_key: &ImageLmsPublicKey,
sig: &ImageLmsSignature,
) -> CaliptraResult<HashValue<SHA192_DIGEST_WORD_SIZE>> {
if self.soc_ifc.verify_in_fake_mode() {
let mut message = [0u8; SHA384_DIGEST_BYTE_SIZE];
for i in 0..digest.len() {
message[i * 4..][..4].copy_from_slice(&digest[i].to_be_bytes());
}
Lms::default().verify_lms_signature_cfi(self.sha256, &message, pub_key, sig)
} else {
// Mock verify, just always return success
Ok(HashValue::from(pub_key.digest))
}
}
fn mldsa87_verify(
&mut self,
msg: &[u8],
pub_key: &ImageMldsaPubKey,
sig: &ImageMldsaSignature,
) -> CaliptraResult<Mldsa87Result> {
if self.soc_ifc.verify_in_fake_mode() {
let pub_key = Mldsa87PubKey::from(pub_key.0);
let sig = Mldsa87Signature::from(sig.0);
self.mldsa87.verify_var(&pub_key, &msg, &sig)
} else {
// Mock verify, just always return success
Ok(Mldsa87Result::Success)
}
}
/// Retrieve Vendor Public Key Digest
fn vendor_pub_key_info_digest_fuses(&self) -> ImageDigest384 {
self.soc_ifc.fuse_bank().vendor_pub_key_info_hash().into()
}
/// Retrieve Vendor ECC Public Key Revocation Bitmask
fn vendor_ecc_pub_key_revocation(&self) -> VendorEccPubKeyRevocation {
self.soc_ifc.fuse_bank().vendor_ecc_pub_key_revocation()
}
/// Retrieve Vendor LMS Public Key Revocation Bitmask
fn vendor_lms_pub_key_revocation(&self) -> u32 {
self.soc_ifc.fuse_bank().vendor_lms_pub_key_revocation()
}
/// Retrieve Vendor MLDSA Public Key Revocation Bitmask
fn vendor_mldsa_pub_key_revocation(&self) -> u32 {
self.soc_ifc.fuse_bank().vendor_mldsa_pub_key_revocation()
}
/// Retrieve Owner Public Key Digest from fuses
fn owner_pub_key_digest_fuses(&self) -> ImageDigest384 {
self.soc_ifc.fuse_bank().owner_pub_key_hash().into()
}
/// Retrieve Anti-Rollback disable fuse value
fn anti_rollback_disable(&self) -> bool {
self.soc_ifc.fuse_bank().anti_rollback_disable()
}
/// Retrieve Device Lifecycle state
fn dev_lifecycle(&self) -> Lifecycle {
self.soc_ifc.lifecycle()
}
/// Get the vendor ECC key index saved in data vault on cold boot
fn vendor_ecc_pub_key_idx_dv(&self) -> u32 {
self.data_vault.vendor_ecc_pk_index()
}
/// Get the vendor LMS key index saved in data vault on cold boot
fn vendor_pqc_pub_key_idx_dv(&self) -> u32 {
self.data_vault.vendor_pqc_pk_index()
}
/// Get the owner public key digest saved in the dv on cold boot
fn owner_pub_key_digest_dv(&self) -> ImageDigest384 {
self.data_vault.owner_pk_hash().into()
}
// Get the fmc digest from the data vault on cold boot
fn get_fmc_digest_dv(&self) -> ImageDigest384 {
self.data_vault.fmc_tci().into()
}
// Get Fuse FW Manifest SVN
fn fw_fuse_svn(&self) -> u32 {
self.soc_ifc.fuse_bank().fw_fuse_svn()
}
fn iccm_range(&self) -> Range<u32> {
caliptra_common::memory_layout::ICCM_RANGE
}
fn set_fw_extended_error(&mut self, err: u32) {
self.soc_ifc.set_fw_extended_error(err);
}
fn pqc_key_type_fuse(&self) -> CaliptraResult<FwVerificationPqcKeyType> {
let pqc_key_type =
FwVerificationPqcKeyType::from_u8(self.soc_ifc.fuse_bank().pqc_key_type() as u8)
.ok_or(CaliptraError::IMAGE_VERIFIER_ERR_INVALID_PQC_KEY_TYPE_IN_FUSE)?;
Ok(pqc_key_type)
}
fn dot_owner_pk_hash(&self) -> Option<&ImageDigest384> {
None
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/uds_programming.rs | rom/dev/src/flow/uds_programming.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
uds_programming.rs
Abstract:
File contains the implementation of UDS programming flow.
--*/
use crate::rom_env::RomEnv;
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_common::cprintln;
use caliptra_common::uds_fe_programming::UdsFeProgrammingFlow;
use caliptra_drivers::{CaliptraError, CaliptraResult, Lifecycle};
/// UDS Programming Flow
pub struct UdsProgrammingFlow {}
impl UdsProgrammingFlow {
#[inline(never)]
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn program_uds(env: &mut RomEnv) -> CaliptraResult<()> {
// Check if UDS programming is requested.
if !env.soc_ifc.uds_program_req() {
return Ok(());
}
// Check if ROM is running in Subsystem mode.
if !env.soc_ifc.subsystem_mode() {
cprintln!("[uds] ROM is not in Active mode.");
Err(CaliptraError::ROM_UDS_PROG_IN_PASSIVE_MODE)?;
}
// Check if ROM is in manufacturing mode.
if env.soc_ifc.lifecycle() != Lifecycle::Manufacturing {
cprintln!("[uds] ROM is not in manufacturing mode.");
Err(CaliptraError::ROM_UDS_PROG_ILLEGAL_LIFECYCLE_STATE)?;
}
let uds_fe_programmer = UdsFeProgrammingFlow::Uds;
// Call the common UDS programming function
uds_fe_programmer.program(&mut env.soc_ifc, &mut env.trng, &env.dma)
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/update_reset.rs | rom/dev/src/flow/update_reset.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
update_reset.rs
Abstract:
File contains the implementation of update reset flow.
--*/
#[cfg(feature = "fake-rom")]
use crate::flow::fake::FakeRomImageVerificationEnv;
use crate::key_ladder;
use crate::{cprintln, pcr, rom_env::RomEnv};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_common::mailbox_api::CommandId;
use caliptra_common::verifier::FirmwareImageVerificationEnv;
use caliptra_common::{handle_fatal_error, RomBootStatus::*};
use caliptra_drivers::{okref, report_boot_status, MailboxRecvTxn, ResetReason, RomPersistentData};
use caliptra_drivers::{report_fw_error_non_fatal, Hmac, Trng};
use caliptra_drivers::{AxiAddr, DataVault, Dma, PersistentData};
use caliptra_error::{CaliptraError, CaliptraResult};
use caliptra_image_types::ImageManifest;
use caliptra_image_verify::{ImageVerificationInfo, ImageVerifier};
use core::mem::size_of;
use zerocopy::{FromBytes, IntoBytes};
#[derive(Default)]
pub struct UpdateResetFlow {}
impl UpdateResetFlow {
/// Execute update reset flow
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn run(env: &mut RomEnv) -> CaliptraResult<()> {
cprintln!("[update-reset] ++");
report_boot_status(UpdateResetStarted.into());
// Check persistent data is valid
let pdata = env.persistent_data.get();
if pdata.rom.marker != RomPersistentData::MAGIC {
handle_fatal_error(CaliptraError::ROM_INVALID_ROM_PERSISTENT_DATA_MARKER.into())
}
// Only check the major version because the minor version may have been modified by FMC
if pdata.rom.major_version != RomPersistentData::MAJOR_VERSION {
handle_fatal_error(CaliptraError::ROM_INVALID_ROM_PERSISTENT_DATA_VERSION.into())
}
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Indicate that Update-Reset flow has started.
// This is used by the next Warm-Reset flow to confirm that the Update-Reset was successful.
// Success status is set at the end of the flow.
data_vault.set_rom_update_reset_status(UpdateResetStarted.into());
let Some(mut recv_txn) = env.mbox.try_start_recv_txn() else {
cprintln!("Failed To Get Mailbox Txn");
return Err(CaliptraError::ROM_UPDATE_RESET_FLOW_MAILBOX_ACCESS_FAILURE);
};
let mut process_txn = || -> CaliptraResult<()> {
// Parse command, staging address, and image size
let (actual_cmd, staging_addr, img_bundle_sz) = if recv_txn.cmd()
== CommandId::EXTERNAL_MAILBOX_CMD.into()
&& env.soc_ifc.subsystem_mode()
{
// Parse ExternalMailboxCmdReq to get actual command and staging address
let mbox_contents = recv_txn.raw_mailbox_contents();
if mbox_contents.len()
< core::mem::size_of::<caliptra_common::mailbox_api::ExternalMailboxCmdReq>()
{
cprintln!("External mailbox command too small");
return Err(CaliptraError::ROM_UPDATE_RESET_FLOW_MAILBOX_ACCESS_FAILURE);
}
let external_cmd =
caliptra_common::mailbox_api::ExternalMailboxCmdReq::ref_from_bytes(
&mbox_contents[..core::mem::size_of::<
caliptra_common::mailbox_api::ExternalMailboxCmdReq,
>()],
)
.map_err(|_| CaliptraError::ROM_UPDATE_RESET_FLOW_MAILBOX_ACCESS_FAILURE)?;
let staging_addr = ((external_cmd.axi_address_start_high as u64) << 32)
| (external_cmd.axi_address_start_low as u64);
(
external_cmd.command_id,
Some(staging_addr),
external_cmd.command_size,
)
} else {
(recv_txn.cmd(), None, recv_txn.dlen())
};
if actual_cmd != CommandId::FIRMWARE_LOAD.into() {
cprintln!("Invalid command 0x{:08x} recv", actual_cmd);
return Err(CaliptraError::ROM_UPDATE_RESET_FLOW_INVALID_FIRMWARE_COMMAND);
}
Self::load_manifest(
env.persistent_data.get_mut(),
&mut recv_txn,
&mut env.soc_ifc,
&mut env.dma,
staging_addr,
)?;
report_boot_status(UpdateResetLoadManifestComplete.into());
let image_source = if env.soc_ifc.subsystem_mode() {
caliptra_common::verifier::ImageSource::McuSram(&env.dma)
} else {
caliptra_common::verifier::ImageSource::MboxMemory(recv_txn.raw_mailbox_contents())
};
let mut venv = FirmwareImageVerificationEnv {
sha256: &mut env.sha256,
sha2_512_384: &mut env.sha2_512_384,
sha2_512_384_acc: &mut env.sha2_512_384_acc,
soc_ifc: &mut env.soc_ifc,
ecc384: &mut env.ecc384,
mldsa87: &mut env.mldsa87,
data_vault: &env.persistent_data.get().rom.data_vault,
pcr_bank: &mut env.pcr_bank,
image_source,
persistent_data: env.persistent_data.get(),
};
let info = {
let manifest = &env.persistent_data.get().rom.manifest2;
Self::verify_image(&mut venv, manifest, img_bundle_sz)
};
let info = okref(&info)?;
report_boot_status(UpdateResetImageVerificationComplete.into());
// Populate data vault
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
Self::populate_data_vault(data_vault, info, &mut env.hmac, &mut env.trng)?;
// Extend PCR0 and PCR1
pcr::extend_pcrs(
env.persistent_data.get_mut(),
&env.soc_ifc,
&mut env.pcr_bank,
&mut env.sha2_512_384,
info,
)?;
report_boot_status(UpdateResetExtendPcrComplete.into());
cprintln!(
"[update-reset] Img verified w/ Vendor ECC Key Index {}",
info.vendor_ecc_pub_key_idx
);
let manifest = &env.persistent_data.get().rom.manifest2;
Self::load_image(
manifest,
&mut recv_txn,
&mut env.soc_ifc,
&mut env.dma,
staging_addr,
)?;
Ok(())
};
if let Err(e) = process_txn() {
// To prevent a race condition where the SoC sees the mailbox
// transaction fail and reads the non-fatal error register before it
// gets populated, report the non-fatal error code now.
report_fw_error_non_fatal(e.into());
return Err(e);
}
// Drop the transaction and release the Mailbox lock after the image
// has been successfully verified and loaded in memory
drop(recv_txn);
report_boot_status(UpdateResetLoadImageComplete.into());
let persistent_data = env.persistent_data.get_mut();
persistent_data.rom.manifest1 = persistent_data.rom.manifest2;
report_boot_status(UpdateResetOverwriteManifestComplete.into());
// Set RT version. FMC does not change.
env.soc_ifc
.set_rt_fw_rev_id(persistent_data.rom.manifest1.runtime.version);
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
data_vault.set_rom_update_reset_status(UpdateResetComplete.into());
cprintln!("[update-reset Success] --");
report_boot_status(UpdateResetComplete.into());
Ok(())
}
/// Verify the image
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * 'manifest'- Manifest
///
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn verify_image(
env: &mut FirmwareImageVerificationEnv,
manifest: &ImageManifest,
img_bundle_sz: u32,
) -> CaliptraResult<ImageVerificationInfo> {
#[cfg(feature = "fake-rom")]
let env = &mut FakeRomImageVerificationEnv {
sha256: env.sha256,
sha2_512_384: env.sha2_512_384,
sha2_512_384_acc: env.sha2_512_384_acc,
soc_ifc: env.soc_ifc,
data_vault: env.data_vault,
ecc384: env.ecc384,
mldsa87: env.mldsa87,
image_source: match &env.image_source {
caliptra_common::verifier::ImageSource::MboxMemory(img) => {
crate::flow::fake::ImageSource::Memory(img)
}
caliptra_common::verifier::ImageSource::McuSram(dma) => {
crate::flow::fake::ImageSource::McuSram(dma)
}
_ => panic!("Image source cannot be fips test"),
},
};
let mut verifier = ImageVerifier::new(env);
let info = verifier.verify(manifest, img_bundle_sz, ResetReason::UpdateReset)?;
Ok(info)
}
/// Load the image to ICCM & DCCM
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `txn` - Mailbox Receive Transaction
/// * `soc_ifc` - SoC Interface
/// * `dma` - DMA engine
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image(
manifest: &ImageManifest,
txn: &mut MailboxRecvTxn,
soc_ifc: &mut caliptra_drivers::SocIfc,
dma: &mut Dma,
staging_addr: Option<u64>,
) -> CaliptraResult<()> {
if soc_ifc.subsystem_mode() {
let addr =
staging_addr.ok_or(CaliptraError::ROM_UPDATE_RESET_FLOW_IMAGE_NOT_IN_MCU_SRAM)?;
Self::load_image_from_mcu(manifest, dma, addr)?;
} else {
Self::load_image_from_mbox(manifest, txn)?;
}
// Call the complete here to reset the execute bit
txn.complete(true)?;
Ok(())
}
/// Load the image from mailbox SRAM to ICCM
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `txn` - Mailbox Receive Transaction
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image_from_mbox(
manifest: &ImageManifest,
txn: &mut MailboxRecvTxn,
) -> CaliptraResult<()> {
cprintln!(
"[update-reset] Loading Runtime at addr 0x{:08x} len {}",
manifest.runtime.load_addr,
manifest.runtime.size
);
let mbox_sram = txn.raw_mailbox_contents();
let runtime_dest = unsafe {
let addr = (manifest.runtime.load_addr) as *mut u8;
core::slice::from_raw_parts_mut(addr, manifest.runtime.size as usize)
};
let start = size_of::<ImageManifest>() + manifest.fmc.size as usize;
let end = start + runtime_dest.len();
if start > end || mbox_sram.len() < end {
Err(CaliptraError::ROM_UPDATE_RESET_FLOW_MAILBOX_ACCESS_FAILURE)?;
}
runtime_dest.copy_from_slice(&mbox_sram[start..end]);
Ok(())
}
/// Load the image from MCU SRAM to ICCM using DMA
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `soc_ifc` - SoC Interface
/// * `dma` - DMA engine
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image_from_mcu(
manifest: &ImageManifest,
dma: &mut Dma,
staging_addr: u64,
) -> CaliptraResult<()> {
cprintln!(
"[update-reset] Loading Runtime at addr 0x{:08x} len {} from staging 0x{:016x}",
manifest.runtime.load_addr,
manifest.runtime.size,
staging_addr
);
// Load Runtime from staging area
let runtime_dest = unsafe {
let addr = (manifest.runtime.load_addr) as *mut u8;
core::slice::from_raw_parts_mut(addr, manifest.runtime.size as usize)
};
let runtime_size_words = runtime_dest.len().div_ceil(4);
let runtime_words = unsafe {
core::slice::from_raw_parts_mut(
runtime_dest.as_mut_ptr() as *mut u32,
runtime_size_words,
)
};
let runtime_offset = size_of::<ImageManifest>() + manifest.fmc.size as usize;
let source_addr = AxiAddr::from(staging_addr + runtime_offset as u64);
dma.read_buffer(source_addr, runtime_words);
Ok(())
}
/// Load the manifest
///
/// # Returns
///
/// * `Manifest` - Caliptra Image Bundle Manifest
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest(
persistent_data: &mut PersistentData,
txn: &mut MailboxRecvTxn,
soc_ifc: &mut caliptra_drivers::SocIfc,
dma: &mut Dma,
staging_addr: Option<u64>,
) -> CaliptraResult<()> {
if soc_ifc.subsystem_mode() {
let addr =
staging_addr.ok_or(CaliptraError::ROM_UPDATE_RESET_FLOW_IMAGE_NOT_IN_MCU_SRAM)?;
Self::load_manifest_from_mcu(persistent_data, dma, addr)
} else {
Self::load_manifest_from_mbox(persistent_data, txn)
}
}
/// Load the manifest from mailbox SRAM
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_mbox(
persistent_data: &mut PersistentData,
txn: &mut MailboxRecvTxn,
) -> CaliptraResult<()> {
let manifest = &mut persistent_data.rom.manifest2;
let mbox_sram = txn.raw_mailbox_contents();
let manifest_buf = manifest.as_mut_bytes();
if mbox_sram.len() < manifest_buf.len() {
Err(CaliptraError::ROM_UPDATE_RESET_FLOW_MAILBOX_ACCESS_FAILURE)?;
}
manifest_buf.copy_from_slice(&mbox_sram[..manifest_buf.len()]);
Ok(())
}
/// Load the manifest from MCU SRAM using DMA
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_mcu(
persistent_data: &mut PersistentData,
dma: &mut Dma,
staging_addr: u64,
) -> CaliptraResult<()> {
let manifest = &mut persistent_data.rom.manifest2;
let manifest_buf = manifest.as_mut_bytes();
// Read manifest from staging area using DMA directly into manifest buffer
let manifest_size_words = manifest_buf.len().div_ceil(4); // Round up to word boundary
let manifest_words = unsafe {
core::slice::from_raw_parts_mut(
manifest_buf.as_mut_ptr() as *mut u32,
manifest_size_words,
)
};
let source_addr = AxiAddr::from(staging_addr);
dma.read_buffer(source_addr, manifest_words);
Ok(())
}
/// Populate data vault
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `info` - Image Verification Info
/// * `hmac` - HMAC helper
/// * `trng` - TRNG helper
fn populate_data_vault(
data_vault: &mut DataVault,
info: &ImageVerificationInfo,
hmac: &mut Hmac,
trng: &mut Trng,
) -> CaliptraResult<()> {
data_vault.set_rt_tci(&info.runtime.digest.into());
let old_min_svn = data_vault.fw_min_svn();
let new_min_svn = core::cmp::min(old_min_svn, info.fw_svn);
data_vault.set_fw_svn(info.fw_svn);
data_vault.set_fw_min_svn(new_min_svn);
data_vault.set_rt_entry_point(info.runtime.entry_point);
report_boot_status(UpdateResetPopulateDataVaultComplete.into());
// Extend the key ladder if the min-SVN is being decremented.
let decrement_by = old_min_svn - new_min_svn;
cprintln!("[update-reset] Extending key ladder by {}", decrement_by);
key_ladder::extend_key_ladder(hmac, trng, decrement_by)?;
report_boot_status(UpdateResetExtendKeyLadderComplete.into());
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/mod.rs | rom/dev/src/flow/mod.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
mod.rs
Abstract:
File contains the top level dispatch of various ROM Flows.
--*/
mod cold_reset;
pub mod debug_unlock;
#[cfg(feature = "fake-rom")]
mod fake;
pub(crate) mod uds_programming;
mod update_reset;
mod warm_reset;
pub use crate::flow::uds_programming::UdsProgrammingFlow;
use crate::{handle_fatal_error, rom_env::RomEnv};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_mod_fn;
use caliptra_cfi_lib::cfi_assert_eq;
use caliptra_drivers::{CaliptraResult, ResetReason};
use caliptra_error::CaliptraError;
/// Execute ROM Flows based on reset reason
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
pub fn run(env: &mut RomEnv) -> CaliptraResult<()> {
let reset_reason = env.soc_ifc.reset_reason();
if cfg!(not(feature = "fake-rom")) {
match reset_reason {
// Cold Reset Flow
ResetReason::ColdReset => {
cfi_assert_eq(env.soc_ifc.reset_reason(), ResetReason::ColdReset);
cold_reset::ColdResetFlow::run(env)
}
// Warm Reset Flow
ResetReason::WarmReset => {
cfi_assert_eq(env.soc_ifc.reset_reason(), ResetReason::WarmReset);
warm_reset::WarmResetFlow::run(env)
}
// Update Reset Flow
ResetReason::UpdateReset => {
cfi_assert_eq(env.soc_ifc.reset_reason(), ResetReason::UpdateReset);
update_reset::UpdateResetFlow::run(env)
}
// Unknown/Spurious Reset Flow
ResetReason::Unknown => {
cfi_assert_eq(env.soc_ifc.reset_reason(), ResetReason::Unknown);
Err(CaliptraError::ROM_UNKNOWN_RESET_FLOW)
}
}
} else {
let _result: CaliptraResult<()> = Err(CaliptraError::ROM_GLOBAL_PANIC);
if (env.soc_ifc.lifecycle() == caliptra_drivers::Lifecycle::Production)
&& !(env.soc_ifc.prod_en_in_fake_mode())
{
handle_fatal_error(CaliptraError::ROM_GLOBAL_FAKE_ROM_IN_PRODUCTION.into());
}
#[cfg(feature = "fake-rom")]
let _result = fake::FakeRomFlow::run(env);
_result
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/warm_reset.rs | rom/dev/src/flow/warm_reset.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
warm_reset.rs
Abstract:
File contains the implementation of warm reset flow.
--*/
use crate::{cprintln, rom_env::RomEnv};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_cfi_lib::{cfi_assert_eq, cfi_assert_ne, cfi_launder};
use caliptra_common::{handle_fatal_error, RomBootStatus::*};
use caliptra_drivers::RomPersistentData;
use caliptra_error::{CaliptraError, CaliptraResult};
/// Warm Reset Flow
pub struct WarmResetFlow {}
impl WarmResetFlow {
/// Execute update reset flow
///
/// # Arguments
///
/// * `env` - ROM Environment
#[inline(never)]
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn run(env: &mut RomEnv) -> CaliptraResult<()> {
cprintln!("[warm-reset] ++");
// Check persistent data is valid
let pdata = env.persistent_data.get();
if pdata.rom.marker != RomPersistentData::MAGIC {
handle_fatal_error(CaliptraError::ROM_INVALID_ROM_PERSISTENT_DATA_MARKER.into())
}
// Only check the major version because the minor version may have been modified by FMC
if pdata.rom.major_version != RomPersistentData::MAJOR_VERSION {
handle_fatal_error(CaliptraError::ROM_INVALID_ROM_PERSISTENT_DATA_VERSION.into())
}
let data_vault = &env.persistent_data.get().rom.data_vault;
// Check if previous Cold-Reset was successful.
if cfi_launder(data_vault.rom_cold_boot_status()) != ColdResetComplete.into() {
return Err(CaliptraError::ROM_WARM_RESET_UNSUCCESSFUL_PREVIOUS_COLD_RESET);
} else {
cfi_assert_eq(data_vault.rom_cold_boot_status(), ColdResetComplete.into());
}
// Check if previous Update-Reset, if any, was successful.
if cfi_launder(data_vault.rom_update_reset_status()) == UpdateResetStarted.into() {
return Err(CaliptraError::ROM_WARM_RESET_UNSUCCESSFUL_PREVIOUS_UPDATE_RESET);
} else {
cfi_assert_ne(
data_vault.rom_update_reset_status(),
UpdateResetStarted.into(),
);
}
cprintln!("[warm-reset] --");
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/debug_unlock.rs | rom/dev/src/flow/debug_unlock.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
debug_unlock.rs
Abstract:
File contains the code to handle debug unlock
--*/
use core::mem::ManuallyDrop;
use crate::flow::cold_reset::fw_processor::FirmwareProcessor;
use crate::CaliptraResult;
use caliptra_api::mailbox::{
MailboxRespHeader, ManufDebugUnlockTokenReq, ProductionAuthDebugUnlockChallenge,
ProductionAuthDebugUnlockReq, ProductionAuthDebugUnlockToken,
};
use caliptra_cfi_lib::{cfi_launder, CfiCounter};
use caliptra_common::{cprintln, debug_unlock, mailbox_api::CommandId};
use caliptra_drivers::Lifecycle;
use caliptra_error::CaliptraError;
use zerocopy::IntoBytes;
use crate::rom_env::RomEnv;
/// Debug Unlock Flow
///
/// # Arguments
///
/// * `env` - ROM Environment
pub fn debug_unlock(env: &mut RomEnv) -> CaliptraResult<()> {
if env.soc_ifc.ss_debug_intent() {
// Clear the device secrets if debug intent is set.
env.doe.clear_secrets()?;
}
if !env.soc_ifc.ss_debug_unlock_req()? {
return Ok(());
}
if !env.soc_ifc.subsystem_mode() {
Err(CaliptraError::SS_DBG_UNLOCK_REQ_IN_PASSIVE_MODE)?;
}
let lifecycle = env.soc_ifc.lifecycle();
match lifecycle {
Lifecycle::Production => handle_production(env),
Lifecycle::Manufacturing => handle_manufacturing(env),
_ => Ok(()),
}
}
fn handle_manufacturing(env: &mut RomEnv) -> CaliptraResult<()> {
cprintln!("[dbg_manuf] ++");
// Set debug unlock in progress and unlock the mailbox for tap access.
env.soc_ifc.set_ss_dbg_unlock_in_progress(true);
let mbox = &mut env.mbox;
let txn = loop {
// Random delay for CFI glitch protection.
CfiCounter::delay();
match mbox.peek_recv() {
Some(txn) => break txn,
None => continue,
}
};
if CommandId::from(txn.cmd()) != CommandId::MANUF_DEBUG_UNLOCK_REQ_TOKEN {
env.soc_ifc.set_ss_dbg_unlock_in_progress(false);
Err(CaliptraError::SS_DBG_UNLOCK_MANUF_INVALID_MBOX_CMD)?;
}
let mut txn = ManuallyDrop::new(txn.start_txn());
let result = (|| {
// Get command bytes and verify checksum
let cmd_bytes = FirmwareProcessor::get_and_verify_cmd_bytes(&txn)?;
// Copy request data since it needs to persist
let mut request = ManufDebugUnlockTokenReq::default();
let request_bytes = request.as_mut_bytes();
if cmd_bytes.len() != request_bytes.len() {
return Err(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH);
}
request_bytes.copy_from_slice(cmd_bytes);
// Hash the token.
let input_token_digest = env.sha2_512_384.sha512_digest(&request.token)?;
let fuse_token_digest = env.soc_ifc.fuse_bank().manuf_dbg_unlock_token();
if cfi_launder(input_token_digest) != fuse_token_digest {
Err(CaliptraError::SS_DBG_UNLOCK_MANUF_INVALID_TOKEN)?;
} else {
caliptra_cfi_lib::cfi_assert_eq_16_words(&input_token_digest.0, &fuse_token_digest.0);
}
Ok(())
})();
let resp = MailboxRespHeader::default();
txn.send_response(resp.as_bytes())?;
match result {
Ok(()) => {
env.soc_ifc.set_ss_dbg_unlock_result(true);
}
Err(_) => {
env.soc_ifc.set_ss_dbg_unlock_result(false);
}
}
env.soc_ifc.set_ss_dbg_unlock_in_progress(false);
cprintln!("[dbg_manuf] --");
result
}
fn handle_auth_debug_unlock_request(
env: &mut RomEnv,
) -> CaliptraResult<(
ProductionAuthDebugUnlockReq,
ProductionAuthDebugUnlockChallenge,
)> {
let mbox = &mut env.mbox;
let txn = loop {
// Random delay for CFI glitch protection.
CfiCounter::delay();
match mbox.peek_recv() {
Some(txn) => break txn,
None => continue,
}
};
if CommandId::from(txn.cmd()) != CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_REQ {
cprintln!(
"Invalid command: {:?}, was expecting PRODUCTION_AUTH_DEBUG_UNLOCK_REQ",
txn.cmd()
);
Err(CaliptraError::SS_DBG_UNLOCK_PROD_INVALID_REQ_MBOX_CMD)?
}
let mut txn = ManuallyDrop::new(txn.start_txn());
// Get command bytes and verify checksum
let cmd_bytes = FirmwareProcessor::get_and_verify_cmd_bytes(&txn)?;
// Copy request data since it needs to persist
let mut request = ProductionAuthDebugUnlockReq::default();
let request_bytes = request.as_mut_bytes();
if cmd_bytes.len() != request_bytes.len() {
return Err(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH);
}
request_bytes.copy_from_slice(cmd_bytes);
// Use common function to create challenge
let challenge =
debug_unlock::create_debug_unlock_challenge(&mut env.trng, &env.soc_ifc, &request);
// Send response
match challenge {
Err(err) => {
txn.send_response(MailboxRespHeader::default().as_bytes())?;
Err(err)
}
Ok(challenge_resp) => {
txn.send_response(challenge_resp.as_bytes())?;
Ok((request, challenge_resp))
}
}
}
fn handle_auth_debug_unlock_token(
env: &mut RomEnv,
request: &ProductionAuthDebugUnlockReq,
challenge: &ProductionAuthDebugUnlockChallenge,
) -> CaliptraResult<()> {
let mbox = &mut env.mbox;
let txn = loop {
// Random delay for CFI glitch protection.
CfiCounter::delay();
match mbox.peek_recv() {
Some(txn) => break txn,
None => continue,
}
};
if CommandId::from(txn.cmd()) != CommandId::PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN {
cprintln!(
"Invalid command: {:?}, was expecting PRODUCTION_AUTH_DEBUG_UNLOCK_TOKEN",
txn.cmd()
);
Err(CaliptraError::SS_DBG_UNLOCK_PROD_INVALID_TOKEN_MBOX_CMD)?;
}
let mut txn = ManuallyDrop::new(txn.start_txn());
// Get command bytes and verify checksum
let cmd_bytes = FirmwareProcessor::get_and_verify_cmd_bytes(&txn)?;
// Copy token data
let mut token = ProductionAuthDebugUnlockToken::default();
let token_bytes = token.as_mut_bytes();
if cmd_bytes.len() != token_bytes.len() {
return Err(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH);
}
token_bytes.copy_from_slice(cmd_bytes);
// Use common validation function
let result = debug_unlock::validate_debug_unlock_token(
&env.soc_ifc,
&mut env.sha2_512_384,
&mut env.sha2_512_384_acc,
&mut env.ecc384,
&mut env.mldsa87,
&mut env.dma,
request,
challenge,
&token,
);
// Send response
let _ = txn.send_response(MailboxRespHeader::default().as_bytes());
result
}
fn handle_production(env: &mut RomEnv) -> CaliptraResult<()> {
cprintln!("[dbg_prod] ++");
env.soc_ifc.set_ss_dbg_unlock_in_progress(true);
let mut debug_unlock_op = || -> CaliptraResult<u8> {
let (request, challenge) = handle_auth_debug_unlock_request(env)?;
handle_auth_debug_unlock_token(env, &request, &challenge)?;
Ok(request.unlock_level)
};
let result = debug_unlock_op();
match result {
Ok(unlock_level) => {
env.soc_ifc.set_ss_dbg_unlock_level(unlock_level);
cprintln!("[dbg_prod] Debug unlock successful");
env.soc_ifc.set_ss_dbg_unlock_result(true);
}
Err(_) => {
cprintln!("[dbg_prod] Debug unlock failed");
env.soc_ifc.set_ss_dbg_unlock_result(false);
}
}
env.soc_ifc.set_ss_dbg_unlock_in_progress(false);
cprintln!("[dbg_prod] --");
result.map(|_| ())
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/ldev_id.rs | rom/dev/src/flow/cold_reset/ldev_id.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
ldev_id.rs
Abstract:
File contains the implementation of DICE Local Device Identity (LDEVID)
layer.
--*/
use super::dice::*;
use crate::cprintln;
use crate::flow::cold_reset::{copy_tbs, TbsType};
use crate::print::HexBytes;
use crate::rom_env::RomEnv;
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_cfi_lib::{cfi_assert, cfi_assert_bool, cfi_launder};
use caliptra_common::keyids::{KEY_ID_STABLE_IDEV, KEY_ID_STABLE_LDEV};
use caliptra_common::{
crypto::{Crypto, Ecc384KeyPair, MlDsaKeyPair, PubKey},
keyids::{
KEY_ID_FE, KEY_ID_LDEVID_ECDSA_PRIV_KEY, KEY_ID_LDEVID_MLDSA_KEYPAIR_SEED,
KEY_ID_ROM_FMC_CDI,
},
x509,
RomBootStatus::*,
};
use caliptra_drivers::*;
use caliptra_x509::*;
use zerocopy::IntoBytes;
use zeroize::Zeroize;
/// Dice Local Device Identity (IDEVID) Layer
#[derive(Default)]
pub struct LocalDevIdLayer {}
impl LocalDevIdLayer {
/// Perform derivations for the DICE layer
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `input` - Dice input
///
/// # Returns
///
/// * `DiceOutput` - key pair, subject identifier serial number, subject key identifier
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn derive(env: &mut RomEnv, input: &DiceInput) -> CaliptraResult<DiceOutput> {
cprintln!("[ldev] ++");
cprintln!("[ldev] CDI.KEYID = {}", KEY_ID_ROM_FMC_CDI as u8);
cprintln!(
"[ldev] ECC SUBJECT.KEYID = {}, MLDSA SUBJECT.KEYID = {}",
KEY_ID_LDEVID_ECDSA_PRIV_KEY as u8,
KEY_ID_LDEVID_MLDSA_KEYPAIR_SEED as u8,
);
cprintln!(
"[ldev] ECC AUTHORITY.KEYID = {}, MLDSA AUTHORITY.KEYID = {}",
input.ecc_auth_key_pair.priv_key as u8,
input.mldsa_auth_key_pair.key_pair_seed as u8,
);
cprintln!("[ldev] FE.KEYID = {}", KEY_ID_FE as u8);
// Derive the stable identity root IDevID key
Self::derive_stable_identity_root_idev(env, KEY_ID_ROM_FMC_CDI, KEY_ID_STABLE_IDEV)?;
// The measurement for this layer is generated by previous layer
// (Initial Device ID DICE Layer).
//
// This is the decrypted Field Entropy
Self::derive_cdi(env, KEY_ID_FE, KEY_ID_ROM_FMC_CDI)?;
// Derive the stable identity root LDevID key
Self::derive_stable_identity_root_ldev(env, KEY_ID_ROM_FMC_CDI, KEY_ID_STABLE_LDEV)?;
// Derive DICE ECC and MLDSA Key Pairs from CDI
let (ecc_key_pair, mldsa_key_pair) = Self::derive_key_pair(
env,
KEY_ID_ROM_FMC_CDI,
KEY_ID_LDEVID_ECDSA_PRIV_KEY,
KEY_ID_LDEVID_MLDSA_KEYPAIR_SEED,
)?;
// Generate the Subject Serial Number and Subject Key Identifier.
//
// This information will be used by the next DICE Layer while generating
// certificates
let ecc_subj_sn = x509::subj_sn(&mut env.sha256, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_sn =
x509::subj_sn(&mut env.sha256, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(LDevIdSubjIdSnGenerationComplete.into());
let ecc_subj_key_id =
x509::subj_key_id(&mut env.sha256, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_key_id =
x509::subj_key_id(&mut env.sha256, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(LDevIdSubjKeyIdGenerationComplete.into());
// Generate the output for next layer
let output = DiceOutput {
ecc_subj_key_pair: ecc_key_pair,
ecc_subj_sn,
ecc_subj_key_id,
mldsa_subj_key_pair: mldsa_key_pair,
mldsa_subj_sn,
mldsa_subj_key_id,
};
// Generate Local Device ID Certificate
Self::generate_cert_sig_ecc(env, input, &output)?;
Self::generate_cert_sig_mldsa(env, input, &output)?;
cprintln!("[ldev] --");
report_boot_status(LDevIdDerivationComplete.into());
Ok(output)
}
/// Derive Composite Device Identity (CDI) from field entropy
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `fe` - Key slot holding the field entropy
/// * `cdi` - Key Slot to store the generated CDI
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_cdi(env: &mut RomEnv, fe: KeyId, cdi: KeyId) -> CaliptraResult<()> {
Crypto::hmac_mac(
&mut env.hmac,
&mut env.trng,
cdi,
b"ldevid_cdi".into(),
cdi,
HmacMode::Hmac512,
KeyUsage::default().set_hmac_key_en(),
)?;
Crypto::hmac_mac(
&mut env.hmac,
&mut env.trng,
cdi,
KeyReadArgs::new(fe).into(),
cdi,
HmacMode::Hmac512,
KeyUsage::default()
.set_ecc_key_gen_seed_en()
.set_mldsa_key_gen_seed_en()
.set_hmac_key_en(),
)?;
cprintln!("[ldev] Erasing FE.KEYID = {}", fe as u8);
env.key_vault.erase_key(fe)?;
report_boot_status(LDevIdCdiDerivationComplete.into());
Ok(())
}
/// Derive stable identity root key from IDevID CDI.
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `idev` - Key slot holding the IDevID CDI
/// * `stable_idev` - Key Slot to store the generated stable identity root IDevID key
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_stable_identity_root_idev(
env: &mut RomEnv,
idev: KeyId,
stable_idev: KeyId,
) -> CaliptraResult<()> {
cprintln!(
"[ldev] Deriving DOT_STABLE_IDEV.KEYID = {}",
stable_idev as u8
);
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
idev,
b"stable_identity_root_idev",
None,
stable_idev,
HmacMode::Hmac512,
KeyUsage::default().set_aes_key_en(),
)?;
Ok(())
}
/// Derive stable identity root key from LDevID CDI.
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `ldev` - Key slot holding the LDevID CDI
/// * `stable_ldev` - Key Slot to store the generated stable identity root LDevID key
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_stable_identity_root_ldev(
env: &mut RomEnv,
ldev: KeyId,
stable_ldev: KeyId,
) -> CaliptraResult<()> {
cprintln!(
"[ldev] Deriving DOT_STABLE_LDEV.KEYID = {}",
stable_ldev as u8
);
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
ldev,
b"stable_identity_root_ldev",
None,
stable_ldev,
HmacMode::Hmac512,
KeyUsage::default().set_aes_key_en(),
)?;
Ok(())
}
/// Derive Dice Layer Key Pair
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `cdi` - Composite Device Identity
/// * `ecc_priv_key` - Key slot to store the ECC private key into
/// * `mldsa_keypair_seed` - Key slot to store the MLDSA key pair seed
///
/// # Returns
///
/// * `(Ecc384KeyPair, MlDsaKeyPair)` - DICE Layer ECC and MLDSA Key Pairs
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_key_pair(
env: &mut RomEnv,
cdi: KeyId,
ecc_priv_key: KeyId,
mldsa_keypair_seed: KeyId,
) -> CaliptraResult<(Ecc384KeyPair, MlDsaKeyPair)> {
let result = Crypto::ecc384_key_gen(
&mut env.ecc384,
&mut env.hmac,
&mut env.trng,
&mut env.key_vault,
cdi,
b"ldevid_ecc_key",
ecc_priv_key,
);
if cfi_launder(result.is_ok()) {
cfi_assert!(result.is_ok());
} else {
cfi_assert!(result.is_err());
}
let ecc_keypair = result?;
// Derive the MLDSA Key Pair.
let result = Crypto::mldsa87_key_gen(
&mut env.mldsa87,
&mut env.hmac,
&mut env.trng,
cdi,
b"ldevid_mldsa_key",
mldsa_keypair_seed,
);
if cfi_launder(result.is_ok()) {
cfi_assert!(result.is_ok());
} else {
cfi_assert!(result.is_err());
}
let mldsa_keypair = result?;
report_boot_status(LDevIdKeyPairDerivationComplete.into());
Ok((ecc_keypair, mldsa_keypair))
}
/// Generate ECC Local Device ID Certificate Signature
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `input` - DICE Input
/// * `output` - DICE Output
fn generate_cert_sig_ecc(
env: &mut RomEnv,
input: &DiceInput,
output: &DiceOutput,
) -> CaliptraResult<()> {
let ecc_auth_priv_key = input.ecc_auth_key_pair.priv_key;
let ecc_auth_pub_key = &input.ecc_auth_key_pair.pub_key;
let ecc_pub_key = &output.ecc_subj_key_pair.pub_key;
let ecc_serial_number = x509::ecc_cert_sn(&mut env.sha256, ecc_pub_key);
let ecc_serial_number = okref(&ecc_serial_number)?;
// CSR `To Be Signed` Parameters
let ecc_tbs_params = LocalDevIdCertTbsEcc384Params {
ueid: &x509::ueid(&env.soc_ifc)?,
subject_sn: &output.ecc_subj_sn,
subject_key_id: &output.ecc_subj_key_id,
issuer_sn: input.ecc_auth_sn,
authority_key_id: input.ecc_auth_key_id,
serial_number: ecc_serial_number,
public_key: &ecc_pub_key.to_der(),
not_before: &NotBefore::default().value,
not_after: &NotAfter::default().value,
};
// Generate the ECC `To Be Signed` portion of the CSR
let ecc_tbs = LocalDevIdCertTbsEcc384::new(&ecc_tbs_params);
// Sign the `To Be Signed` portion
cprintln!(
"[ldev] Signing Cert with ECC AUTHORITY.KEYID = {}",
ecc_auth_priv_key as u8
);
let mut sig = Crypto::ecdsa384_sign_and_verify(
&mut env.sha2_512_384,
&mut env.ecc384,
&mut env.trng,
ecc_auth_priv_key,
ecc_auth_pub_key,
ecc_tbs.tbs(),
);
let sig = okmutref(&mut sig)?;
// Clear the authority private key
env.key_vault
.erase_key(ecc_auth_priv_key)
.inspect_err(|_err| {
sig.zeroize();
})?;
let _pub_x: [u8; 48] = (&ecc_pub_key.x).into();
let _pub_y: [u8; 48] = (&ecc_pub_key.y).into();
cprintln!("[ldev] PUB.X = {}", HexBytes(&_pub_x));
cprintln!("[ldev] PUB.Y = {}", HexBytes(&_pub_y));
let _sig_r: [u8; 48] = (&sig.r).into();
let _sig_s: [u8; 48] = (&sig.s).into();
cprintln!("[ldev] SIG.R = {}", HexBytes(&_sig_r));
cprintln!("[ldev] SIG.S = {}", HexBytes(&_sig_s));
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Save the Local Device ID cert signature in data vault.
data_vault.set_ldev_dice_ecc_signature(sig);
sig.zeroize();
// Save the Local Device ID public key in data vault.
data_vault.set_ldev_dice_ecc_pub_key(ecc_pub_key);
// Copy TBS to DCCM.
copy_tbs(ecc_tbs.tbs(), TbsType::EccLdevid, env)?;
Ok(())
}
/// Generate MLDSA Local Device ID Certificate Signature
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `input` - DICE Input
/// * `output` - DICE Output
fn generate_cert_sig_mldsa(
env: &mut RomEnv,
input: &DiceInput,
output: &DiceOutput,
) -> CaliptraResult<()> {
let mldsa_auth_priv_key = input.mldsa_auth_key_pair.key_pair_seed;
let mldsa_auth_pub_key = &input.mldsa_auth_key_pair.pub_key;
let mldsa_pub_key = &output.mldsa_subj_key_pair.pub_key;
let mldsa_serial_number = x509::mldsa_cert_sn(&mut env.sha256, mldsa_pub_key);
let mldsa_serial_number = okref(&mldsa_serial_number)?;
// CSR `To Be Signed` Parameters
let mldsa_tbs_params = LocalDevIdCertTbsMlDsa87Params {
ueid: &x509::ueid(&env.soc_ifc)?,
subject_sn: &output.mldsa_subj_sn,
subject_key_id: &output.mldsa_subj_key_id,
issuer_sn: input.mldsa_auth_sn,
authority_key_id: input.mldsa_auth_key_id,
serial_number: mldsa_serial_number,
public_key: mldsa_pub_key.as_bytes().try_into().unwrap(),
not_before: &NotBefore::default().value,
not_after: &NotAfter::default().value,
};
// Generate the ECC `To Be Signed` portion of the CSR
let mldsa_tbs = LocalDevIdCertTbsMlDsa87::new(&mldsa_tbs_params);
// Sign the `To Be Signed` portion
cprintln!(
"[ldev] Signing Cert with MLDSA AUTHORITY.KEYID = {}",
mldsa_auth_priv_key as u8
);
let mut sig = Crypto::mldsa87_sign_and_verify(
&mut env.mldsa87,
&mut env.trng,
mldsa_auth_priv_key,
mldsa_auth_pub_key,
mldsa_tbs.tbs(),
);
let sig = okmutref(&mut sig)?;
// Clear the authority private key
env.key_vault
.erase_key(mldsa_auth_priv_key)
.inspect_err(|_err| {
sig.zeroize();
})?;
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Save the Local Device ID cert signature in data vault.
data_vault.set_ldev_dice_mldsa_signature(sig);
sig.zeroize();
// Save the Local Device ID public key in data vault.
data_vault.set_ldev_dice_mldsa_pub_key(mldsa_pub_key);
// Copy TBS to DCCM.
copy_tbs(mldsa_tbs.tbs(), TbsType::MldsaLdevid, env)?;
report_boot_status(LDevIdCertSigGenerationComplete.into());
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/ocp_lock.rs | rom/dev/src/flow/cold_reset/ocp_lock.rs | // Licensed under the Apache-2.0 license
use caliptra_api::mailbox::{
OcpLockReportHekMetadataReq, OcpLockReportHekMetadataResp, OcpLockReportHekMetadataRespFlags,
};
use caliptra_cfi_lib::{cfi_assert, cfi_assert_bool, cfi_launder};
use caliptra_common::{
crypto::Crypto,
keyids::{
ocp_lock::{KEY_ID_HEK, KEY_ID_MDK},
KEY_ID_ROM_FMC_CDI,
},
};
use caliptra_drivers::{
Array4x8, CaliptraResult, HekSeedState, HmacMode, KeyUsage, KeyVault, Lifecycle,
PersistentData, SocIfc,
};
use crate::rom_env::RomEnv;
use zerocopy::IntoBytes;
/// Run the OCP LOCK Cold Reset flow
///
/// # Arguments
///
/// * `env` - ROM Environment
pub fn ocp_lock_cold_reset_flow(env: &mut RomEnv) -> CaliptraResult<()> {
if cfi_launder(!env.soc_ifc.ocp_lock_enabled()) {
return Ok(());
} else {
cfi_assert!(env.soc_ifc.ocp_lock_enabled())
}
derive_hek(env)?;
derive_mdk(env)?;
Ok(())
}
/// Derive OCP LOCK HEK
///
/// NOTE: The HEK _may_ be disabled once MCU has reported the HEK seed state.
///
/// # Arguments
///
/// * `env` - ROM Environment
fn derive_hek(env: &mut RomEnv) -> CaliptraResult<()> {
let hek_seed = env.soc_ifc.fuse_bank().ocp_hek_seed();
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
KEY_ID_ROM_FMC_CDI,
b"ocp_lock_hek",
Some(hek_seed.as_bytes()),
KEY_ID_HEK,
HmacMode::Hmac512,
KeyUsage::default().set_hmac_key_en(),
)?;
Ok(())
}
/// Derive OCP LOCK MDK
///
/// # Arguments
///
/// * `env` - ROM Environment
fn derive_mdk(env: &mut RomEnv) -> CaliptraResult<()> {
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
KEY_ID_ROM_FMC_CDI,
b"ocp_lock_mdk",
None,
KEY_ID_MDK,
HmacMode::Hmac512,
KeyUsage::default().set_aes_key_en(),
)?;
Ok(())
}
/// Handle `ReportHekMetadataReq` command from MCU.
///
/// Returns:
/// True if the HEK is available. False otherwise.
pub fn handle_report_hek_metadata(
lifecycle_state: Lifecycle,
pdata: &mut PersistentData,
req: &OcpLockReportHekMetadataReq,
hek_seed: &Array4x8,
) -> CaliptraResult<OcpLockReportHekMetadataResp> {
let hek_seed_state = HekSeedState::try_from(req.seed_state)?;
let hek_available = hek_seed_state.hek_is_available(lifecycle_state, hek_seed);
pdata.rom.ocp_lock_metadata.hek_available = hek_available;
pdata.rom.ocp_lock_metadata.total_hek_seed_slots = req.total_slots;
pdata.rom.ocp_lock_metadata.active_hek_seed_slots = req.active_slots;
pdata.rom.ocp_lock_metadata.hek_seed_state = req.seed_state;
let mut resp = OcpLockReportHekMetadataResp::default();
resp.flags.set(
OcpLockReportHekMetadataRespFlags::HEK_AVAILABLE,
hek_available,
);
Ok(resp)
}
/// Check HEK availability. Must always be called before moving to next boot stage.
///
/// HEK can only be marked available if MCU has called `REPORT_HEK_METADATA`.
///
/// If HEK is available, NOP
/// If HEK is unavailable, erase HEK.
fn zeroize_hek_if_needed(pdata: &mut PersistentData, kv: &mut KeyVault) -> CaliptraResult<()> {
if cfi_launder(pdata.rom.ocp_lock_metadata.hek_available) {
return Ok(());
} else {
cfi_assert!(!pdata.rom.ocp_lock_metadata.hek_available)
}
// HEK seed is not available, erase the HEK.
kv.erase_key(KEY_ID_HEK)
}
/// Completes the OCP LOCK flow after a cold reset.
///
/// Checks the HEK seed state. Sets LOCK in Progress.
pub fn complete_ocp_lock_flow(
soc_ifc: &mut SocIfc,
pdata: &mut PersistentData,
kv: &mut KeyVault,
) -> CaliptraResult<()> {
// Check that ROM has reported the HEK seed's state.
// We must always do this on a cold reset after processing FW commands.
zeroize_hek_if_needed(pdata, kv)?;
// We have completed the OCP LOCK ROM cold reset flow. Set LOCK in progress to enable OCP
// LOCK mode in hardware.
soc_ifc.ocp_lock_set_lock_in_progress();
Ok(())
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/dice.rs | rom/dev/src/flow/cold_reset/dice.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
dice.rs
Abstract:
File contains interface and definitions for common Device Identity
Composition Engine (DICE) functionality.
--*/
use caliptra_common::crypto::{Ecc384KeyPair, MlDsaKeyPair};
use zeroize::Zeroize;
/// DICE Layer Input
#[derive(Debug)]
pub struct DiceInput<'a> {
/// ECC Authority Key Pair
pub ecc_auth_key_pair: &'a Ecc384KeyPair,
/// ECC Authority Serial Number
pub ecc_auth_sn: &'a [u8; 64],
/// ECC Authority Key Identifier
pub ecc_auth_key_id: &'a [u8; 20],
/// MLDSA Authority Key Pair
pub mldsa_auth_key_pair: &'a MlDsaKeyPair,
/// MLDSA Authority Serial Number
pub mldsa_auth_sn: &'a [u8; 64],
/// MLDSA Authority Key Identifier
pub mldsa_auth_key_id: &'a [u8; 20],
}
/// DICE Layer Output
#[derive(Debug, Zeroize)]
pub struct DiceOutput {
/// ECC Subject key pair for this layer
pub ecc_subj_key_pair: Ecc384KeyPair,
/// ECC Subject Serial Number
pub ecc_subj_sn: [u8; 64],
/// ECC Subject Key Identifier
pub ecc_subj_key_id: [u8; 20],
/// MLDSA Subject key pair for this layer
pub mldsa_subj_key_pair: MlDsaKeyPair,
/// MLDSA Subject Serial Number
pub mldsa_subj_sn: [u8; 64],
/// MLDSA Subject Key Identifier
pub mldsa_subj_key_id: [u8; 20],
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fmc_alias.rs | rom/dev/src/flow/cold_reset/fmc_alias.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
fmc_alias.rs
Abstract:
File contains the implementation of DICE First Mutable Code (FMC)
layer.
--*/
use super::dice::{DiceInput, DiceOutput};
use super::fw_processor::FwProcInfo;
use crate::cprintln;
use crate::flow::cold_reset::{copy_tbs, TbsType};
use crate::rom_env::RomEnv;
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_cfi_lib::{cfi_assert, cfi_assert_bool, cfi_launder};
use caliptra_common::cfi_check;
use caliptra_common::crypto::{Crypto, Ecc384KeyPair, MlDsaKeyPair, PubKey};
use caliptra_common::keyids::{
KEY_ID_FMC_ECDSA_PRIV_KEY, KEY_ID_FMC_MLDSA_KEYPAIR_SEED, KEY_ID_ROM_FMC_CDI,
};
use caliptra_common::pcr::PCR_ID_FMC_CURRENT;
use caliptra_common::RomBootStatus::*;
use caliptra_common::{dice, x509};
use caliptra_drivers::KeyUsage;
use caliptra_drivers::{
okmutref, report_boot_status, sha2_512_384::Sha2DigestOpTrait, Array4x12, CaliptraResult,
HmacMode, KeyId,
};
use caliptra_x509::{
FmcAliasCertTbsEcc384, FmcAliasCertTbsEcc384Params, FmcAliasCertTbsMlDsa87,
FmcAliasCertTbsMlDsa87Params,
};
use zeroize::Zeroize;
#[derive(Default)]
pub struct FmcAliasLayer {}
impl FmcAliasLayer {
/// Perform derivations for the DICE layer
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn derive(
env: &mut RomEnv,
input: &DiceInput,
fw_proc_info: &FwProcInfo,
) -> CaliptraResult<()> {
cprintln!("[afmc] ++");
// We use the value of PCR0 as the measurement for deriving the CDI.
let mut measurement = env.pcr_bank.read_pcr(PCR_ID_FMC_CURRENT);
// Derive the DICE CDI from the measurement
let result = Self::derive_cdi(env, &measurement, KEY_ID_ROM_FMC_CDI);
measurement.0.zeroize();
result?;
// Derive DICE ECC and MLDSA Key Pairs from CDI
let (ecc_key_pair, mldsa_key_pair) = Self::derive_key_pair(
env,
KEY_ID_ROM_FMC_CDI,
KEY_ID_FMC_ECDSA_PRIV_KEY,
KEY_ID_FMC_MLDSA_KEYPAIR_SEED,
)?;
// Generate the Subject Serial Number and Subject Key Identifier.
//
// This information will be used by next DICE Layer while generating
// certificates
let ecc_subj_sn = x509::subj_sn(&mut env.sha256, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_sn =
x509::subj_sn(&mut env.sha256, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(FmcAliasSubjIdSnGenerationComplete.into());
let ecc_subj_key_id =
x509::subj_key_id(&mut env.sha256, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_key_id =
x509::subj_key_id(&mut env.sha256, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(FmcAliasSubjKeyIdGenerationComplete.into());
// Generate the output for next layer
let mut output = DiceOutput {
ecc_subj_key_pair: ecc_key_pair,
ecc_subj_sn,
ecc_subj_key_id,
mldsa_subj_key_pair: mldsa_key_pair,
mldsa_subj_sn,
mldsa_subj_key_id,
};
// Generate FMC Alias Certificate
let result: CaliptraResult<()> = (|| {
Self::generate_cert_sig_ecc(env, input, &output, fw_proc_info)?;
Self::generate_cert_sig_mldsa(env, input, &output, fw_proc_info)?;
Ok(())
})();
output.zeroize();
result?;
report_boot_status(FmcAliasDerivationComplete.into());
cprintln!("[afmc] --");
Ok(())
}
/// Derive Composite Device Identity (CDI) from FMC measurements
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `measurements` - Array containing the FMC measurements
/// * `cdi` - Key Slot to store the generated CDI
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_cdi(env: &mut RomEnv, measurements: &Array4x12, cdi: KeyId) -> CaliptraResult<()> {
let mut measurements: [u8; 48] = measurements.into();
let result = Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
cdi,
b"alias_fmc_cdi",
Some(&measurements),
KEY_ID_ROM_FMC_CDI,
HmacMode::Hmac512,
KeyUsage::default()
.set_ecc_key_gen_seed_en()
.set_mldsa_key_gen_seed_en()
.set_hmac_key_en(),
);
measurements.zeroize();
result?;
report_boot_status(FmcAliasDeriveCdiComplete.into());
Ok(())
}
/// Derive Dice Layer Key Pair
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `cdi` - Composite Device Identity
/// * `ecc_priv_key` - Key slot to store the ECC private key into
/// * `mldsa_keypair_seed` - Key slot to store the MLDSA key pair seed
///
/// # Returns
///
/// * `Ecc384KeyPair` - Derive DICE Layer Key Pair
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_key_pair(
env: &mut RomEnv,
cdi: KeyId,
ecc_priv_key: KeyId,
mldsa_keypair_seed: KeyId,
) -> CaliptraResult<(Ecc384KeyPair, MlDsaKeyPair)> {
let result = Crypto::ecc384_key_gen(
&mut env.ecc384,
&mut env.hmac,
&mut env.trng,
&mut env.key_vault,
cdi,
b"alias_fmc_ecc_key",
ecc_priv_key,
);
cfi_check!(result);
let ecc_keypair = result?;
// Derive the MLDSA Key Pair.
let result = Crypto::mldsa87_key_gen(
&mut env.mldsa87,
&mut env.hmac,
&mut env.trng,
cdi,
b"alias_fmc_mldsa_key",
mldsa_keypair_seed,
);
cfi_check!(result);
let mldsa_keypair = result?;
report_boot_status(FmcAliasKeyPairDerivationComplete.into());
Ok((ecc_keypair, mldsa_keypair))
}
/// Generate Local Device ID Certificate Signature
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `input` - DICE Input
/// * `output` - DICE Output
fn generate_cert_sig_ecc(
env: &mut RomEnv,
input: &DiceInput,
output: &DiceOutput,
fw_proc_info: &FwProcInfo,
) -> CaliptraResult<()> {
let auth_priv_key = input.ecc_auth_key_pair.priv_key;
let auth_pub_key = &input.ecc_auth_key_pair.pub_key;
let pub_key = &output.ecc_subj_key_pair.pub_key;
let data_vault = &env.persistent_data.get().rom.data_vault;
let soc_ifc = &env.soc_ifc;
let flags = dice::make_flags(env.soc_ifc.lifecycle(), env.soc_ifc.debug_locked());
let svn = data_vault.cold_boot_fw_svn() as u8;
let fuse_svn = fw_proc_info.effective_fuse_svn as u8;
let mut fuse_info_digest = Array4x12::default();
let mut hasher = env.sha2_512_384.sha384_digest_init()?;
hasher.update(&[
soc_ifc.lifecycle() as u8,
soc_ifc.debug_locked() as u8,
soc_ifc.fuse_bank().anti_rollback_disable() as u8,
data_vault.vendor_ecc_pk_index() as u8,
data_vault.vendor_pqc_pk_index() as u8,
fw_proc_info.pqc_key_type,
fw_proc_info.owner_pub_keys_digest_in_fuses as u8,
])?;
hasher.update(&<[u8; 48]>::from(
soc_ifc.fuse_bank().vendor_pub_key_info_hash(),
))?;
hasher.update(&<[u8; 48]>::from(data_vault.owner_pk_hash()))?;
hasher.finalize(&mut fuse_info_digest)?;
// Certificate `To Be Signed` Parameters
let params = FmcAliasCertTbsEcc384Params {
ueid: &x509::ueid(soc_ifc)?,
subject_sn: &output.ecc_subj_sn,
subject_key_id: &output.ecc_subj_key_id,
issuer_sn: input.ecc_auth_sn,
authority_key_id: input.ecc_auth_key_id,
serial_number: &x509::ecc_cert_sn(&mut env.sha256, pub_key)?,
public_key: &pub_key.to_der(),
tcb_info_fmc_tci: &(&data_vault.fmc_tci()).into(),
tcb_info_device_info_hash: &fuse_info_digest.into(),
tcb_info_flags: &flags,
tcb_info_fw_svn: &svn.to_be_bytes(),
tcb_info_fw_svn_fuses: &fuse_svn.to_be_bytes(),
not_before: &fw_proc_info.fmc_cert_valid_not_before.value,
not_after: &fw_proc_info.fmc_cert_valid_not_after.value,
};
// Generate the `To Be Signed` portion of the CSR
let tbs = FmcAliasCertTbsEcc384::new(¶ms);
// Sign the `To Be Signed` portion
cprintln!(
"[afmc] ECC Signing Cert w/ AUTHORITY.KEYID = {}",
auth_priv_key as u8
);
let mut sig = Crypto::ecdsa384_sign_and_verify(
&mut env.sha2_512_384,
&mut env.ecc384,
&mut env.trng,
auth_priv_key,
auth_pub_key,
tbs.tbs(),
);
let sig = okmutref(&mut sig)?;
// Clear the authority private key
env.key_vault.erase_key(auth_priv_key).inspect_err(|_err| {
sig.zeroize();
})?;
// Set the FMC Certificate Signature in data vault.
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
data_vault.set_fmc_dice_ecc_signature(sig);
sig.zeroize();
// Set the FMC Public key in the data vault.
data_vault.set_fmc_ecc_pub_key(pub_key);
// Copy TBS to DCCM.
copy_tbs(tbs.tbs(), TbsType::EccFmcalias, env)?;
Ok(())
}
/// Generate Local Device ID Certificate Signature
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `input` - DICE Input
/// * `output` - DICE Output
fn generate_cert_sig_mldsa(
env: &mut RomEnv,
input: &DiceInput,
output: &DiceOutput,
fw_proc_info: &FwProcInfo,
) -> CaliptraResult<()> {
let auth_priv_key = input.mldsa_auth_key_pair.key_pair_seed;
let auth_pub_key = &input.mldsa_auth_key_pair.pub_key;
let pub_key = output.mldsa_subj_key_pair.pub_key;
let data_vault = &env.persistent_data.get().rom.data_vault;
let soc_ifc = &env.soc_ifc;
let flags = dice::make_flags(env.soc_ifc.lifecycle(), env.soc_ifc.debug_locked());
let svn = data_vault.fw_svn() as u8;
let fuse_svn = fw_proc_info.effective_fuse_svn as u8;
let mut fuse_info_digest = Array4x12::default();
let mut hasher = env.sha2_512_384.sha384_digest_init()?;
hasher.update(&[
soc_ifc.lifecycle() as u8,
soc_ifc.debug_locked() as u8,
soc_ifc.fuse_bank().anti_rollback_disable() as u8,
data_vault.vendor_ecc_pk_index() as u8,
data_vault.vendor_pqc_pk_index() as u8,
fw_proc_info.pqc_key_type,
fw_proc_info.owner_pub_keys_digest_in_fuses as u8,
])?;
hasher.update(&<[u8; 48]>::from(
soc_ifc.fuse_bank().vendor_pub_key_info_hash(),
))?;
hasher.update(&<[u8; 48]>::from(data_vault.owner_pk_hash()))?;
hasher.finalize(&mut fuse_info_digest)?;
// Certificate `To Be Signed` Parameters
let params = FmcAliasCertTbsMlDsa87Params {
ueid: &x509::ueid(soc_ifc)?,
subject_sn: &output.mldsa_subj_sn,
subject_key_id: &output.mldsa_subj_key_id,
issuer_sn: input.mldsa_auth_sn,
authority_key_id: input.mldsa_auth_key_id,
serial_number: &x509::mldsa_cert_sn(&mut env.sha256, &pub_key)?,
public_key: &pub_key.into(),
tcb_info_fmc_tci: &(&data_vault.fmc_tci()).into(),
tcb_info_device_info_hash: &fuse_info_digest.into(),
tcb_info_flags: &flags,
tcb_info_fw_svn: &svn.to_be_bytes(),
tcb_info_fw_svn_fuses: &fuse_svn.to_be_bytes(),
not_before: &fw_proc_info.fmc_cert_valid_not_before.value,
not_after: &fw_proc_info.fmc_cert_valid_not_after.value,
};
// Generate the `To Be Signed` portion of the CSR
let tbs = FmcAliasCertTbsMlDsa87::new(¶ms);
// Sign the `To Be Signed` portion
cprintln!(
"[afmc] MLDSA Signing Cert w/ AUTHORITY.KEYID = {}",
auth_priv_key as u8
);
let mut sig = Crypto::mldsa87_sign_and_verify(
&mut env.mldsa87,
&mut env.trng,
auth_priv_key,
auth_pub_key,
tbs.tbs(),
);
let sig = okmutref(&mut sig)?;
// Clear the authority private key
cprintln!(
"[afmc] MLDSA Erase AUTHORITY.KEYID = {}",
auth_priv_key as u8
);
env.key_vault.erase_key(auth_priv_key).inspect_err(|_err| {
sig.zeroize();
})?;
// Set the FMC Certificate Signature in data vault.
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
data_vault.set_fmc_dice_mldsa_signature(sig);
sig.zeroize();
// Set the FMC Public key in the data vault.
data_vault.set_fmc_mldsa_pub_key(&pub_key);
// Copy TBS to DCCM.
copy_tbs(tbs.tbs(), TbsType::MldsaFmcalias, env)?;
report_boot_status(FmcAliasCertSigGenerationComplete.into());
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/mod.rs | rom/dev/src/flow/cold_reset/mod.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
mod.rs
Abstract:
File contains the implementation of Cold Reset Flow
--*/
mod dice;
mod fmc_alias;
pub mod fw_processor;
mod idev_id;
mod ldev_id;
mod ocp_lock;
mod x509;
use crate::fht;
use crate::flow::cold_reset::dice::*;
use crate::flow::cold_reset::fmc_alias::FmcAliasLayer;
use crate::flow::cold_reset::fw_processor::FirmwareProcessor;
use crate::flow::cold_reset::idev_id::InitDevIdLayer;
use crate::flow::cold_reset::ldev_id::LocalDevIdLayer;
use crate::{cprintln, rom_env::RomEnv};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::{cfi_impl_fn, cfi_mod_fn};
use caliptra_common::RomBootStatus::*;
use caliptra_drivers::*;
use zerocopy::transmute;
use zeroize::Zeroize;
pub enum TbsType {
EccLdevid = 0,
EccFmcalias = 1,
MldsaLdevid = 2,
MldsaFmcalias = 3,
}
/// Cold Reset Flow
pub struct ColdResetFlow {}
impl ColdResetFlow {
/// Execute Cold Reset Flow
///
/// # Arguments
///
/// * `env` - ROM Environment
#[inline(never)]
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn run(env: &mut RomEnv) -> CaliptraResult<()> {
cprintln!("[cold-reset] ++");
report_boot_status(ColdResetStarted.into());
env.persistent_data.get_mut().rom.marker = RomPersistentData::MAGIC;
env.persistent_data.get_mut().rom.major_version = RomPersistentData::MAJOR_VERSION;
env.persistent_data.get_mut().rom.minor_version = RomPersistentData::MINOR_VERSION;
{
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
// Indicate that Cold-Reset flow has started.
// This is used by the next Warm-Reset flow to confirm that the Cold-Reset was successful.
// Success status is set at the end of the flow.
data_vault.set_rom_cold_boot_status(ColdResetStarted.into());
}
// Initialize FHT
fht::initialize_fht(env);
// Execute IDEVID layer
let mut idevid_layer_output = InitDevIdLayer::derive(env)?;
let ldevid_layer_input = dice_input_from_output(&idevid_layer_output);
// Execute LDEVID layer
let result = LocalDevIdLayer::derive(env, &ldevid_layer_input);
idevid_layer_output.zeroize();
let mut ldevid_layer_output = result?;
let fmc_layer_input = dice_input_from_output(&ldevid_layer_output);
// Generate the CMB AES key
generate_cmb_aes_key(env)?;
// Download and validate firmware.
let mut fw_proc_info = FirmwareProcessor::process(env)?;
// Execute FMCALIAS layer
let result = FmcAliasLayer::derive(env, &fmc_layer_input, &fw_proc_info);
ldevid_layer_output.zeroize();
fw_proc_info.zeroize();
result?;
// Indicate Cold-Reset successful completion.
// This is used by the Warm-Reset flow to confirm that the Cold-Reset was successful.
let data_vault = &mut env.persistent_data.get_mut().rom.data_vault;
data_vault.set_rom_cold_boot_status(ColdResetComplete.into());
report_boot_status(ColdResetComplete.into());
cprintln!("[cold-reset] --");
Ok(())
}
}
/// Generates the cryptographic mailbox AES key.
fn generate_cmb_aes_key(env: &mut RomEnv) -> CaliptraResult<()> {
let key_share0: [u32; 8] = env.trng.generate()?.0[..8].try_into().unwrap();
let key_share1: [u32; 8] = env.trng.generate()?.0[..8].try_into().unwrap();
env.persistent_data.get_mut().rom.cmb_aes_key_share0 = transmute!(key_share0);
env.persistent_data.get_mut().rom.cmb_aes_key_share1 = transmute!(key_share1);
Ok(())
}
/// Copies the TBS to DCCM
///
/// # Arguments
/// * `tbs` - TBS to copy
/// * `tbs_type` - Type of TBS
/// * `env` - ROM Environment
///
/// # Returns
/// CaliptraResult
#[cfg_attr(not(feature = "no-cfi"), cfi_mod_fn)]
#[inline(never)]
pub fn copy_tbs(tbs: &[u8], tbs_type: TbsType, env: &mut RomEnv) -> CaliptraResult<()> {
let persistent_data = env.persistent_data.get_mut();
let dst = match tbs_type {
TbsType::EccLdevid => {
persistent_data.rom.fht.ecc_ldevid_tbs_size = tbs.len() as u16;
persistent_data
.rom
.ecc_ldevid_tbs
.get_mut(..tbs.len())
.ok_or(CaliptraError::ROM_GLOBAL_UNSUPPORTED_LDEVID_TBS_SIZE)?
}
TbsType::EccFmcalias => {
persistent_data.rom.fht.ecc_fmcalias_tbs_size = tbs.len() as u16;
persistent_data
.rom
.ecc_fmcalias_tbs
.get_mut(..tbs.len())
.ok_or(CaliptraError::ROM_GLOBAL_UNSUPPORTED_FMCALIAS_TBS_SIZE)?
}
TbsType::MldsaLdevid => {
persistent_data.rom.fht.mldsa_ldevid_tbs_size = tbs.len() as u16;
persistent_data
.rom
.mldsa_ldevid_tbs
.get_mut(..tbs.len())
.ok_or(CaliptraError::ROM_GLOBAL_UNSUPPORTED_LDEVID_TBS_SIZE)?
}
TbsType::MldsaFmcalias => {
persistent_data.rom.fht.mldsa_fmcalias_tbs_size = tbs.len() as u16;
persistent_data
.rom
.mldsa_fmcalias_tbs
.get_mut(..tbs.len())
.ok_or(CaliptraError::ROM_GLOBAL_UNSUPPORTED_FMCALIAS_TBS_SIZE)?
}
};
dst.copy_from_slice(tbs);
Ok(())
}
fn dice_input_from_output(dice_output: &DiceOutput) -> DiceInput {
DiceInput {
ecc_auth_key_pair: &dice_output.ecc_subj_key_pair,
ecc_auth_sn: &dice_output.ecc_subj_sn,
ecc_auth_key_id: &dice_output.ecc_subj_key_id,
mldsa_auth_key_pair: &dice_output.mldsa_subj_key_pair,
mldsa_auth_sn: &dice_output.mldsa_subj_sn,
mldsa_auth_key_id: &dice_output.mldsa_subj_key_id,
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/idev_id.rs | rom/dev/src/flow/cold_reset/idev_id.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
init_dev_id.rs
Abstract:
File contains the implementation of DICE Initial Device Identity (IDEVID)
layer.
--*/
use super::dice::*;
use crate::cprintln;
use crate::crypto::Ecdsa384SignatureAdapter;
use crate::flow::{cold_reset, cold_reset::ocp_lock};
use crate::print::HexBytes;
use crate::rom_env::RomEnv;
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_cfi_lib::{cfi_assert, cfi_assert_bool, cfi_launder};
use caliptra_common::{
crypto::{Crypto, Ecc384KeyPair, MlDsaKeyPair, PubKey},
keyids::{
KEY_ID_FE, KEY_ID_IDEVID_ECDSA_PRIV_KEY, KEY_ID_IDEVID_MLDSA_KEYPAIR_SEED,
KEY_ID_ROM_FMC_CDI, KEY_ID_UDS,
},
x509,
RomBootStatus::*,
};
use caliptra_drivers::*;
use caliptra_x509::*;
use core::mem::offset_of;
use zerocopy::IntoBytes;
use zeroize::Zeroize;
/// Initialization Vector used by Deobfuscation Engine during UDS / field entropy decryption.
const DOE_IV: Array4x4 = Array4xN::<4, 16>([0xfb10365b, 0xa1179741, 0xfba193a1, 0x0f406d7e]);
/// Dice Initial Device Identity (IDEVID) Layer
pub enum InitDevIdLayer {}
impl InitDevIdLayer {
/// Perform derivations for the DICE layer
///
/// # Arguments
///
/// * `env` - ROM Environment
///
/// # Returns
///
/// * `DiceOutput` - DICE layer output
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
pub fn derive(env: &mut RomEnv) -> CaliptraResult<DiceOutput> {
cprintln!("[idev] ++");
cprintln!("[idev] CDI.KEYID = {}", KEY_ID_ROM_FMC_CDI as u8);
cprintln!(
"[idev] ECC SUBJECT.KEYID = {}, MLDSA SUBJECT.KEYID = {}",
KEY_ID_IDEVID_ECDSA_PRIV_KEY as u8,
KEY_ID_IDEVID_MLDSA_KEYPAIR_SEED as u8
);
cprintln!("[idev] UDS.KEYID = {}", KEY_ID_UDS as u8);
// If CSR is not requested, indicate to the SOC that it can start
// uploading the firmware image to the mailbox.
if !env.soc_ifc.mfg_flag_gen_idev_id_csr() {
env.soc_ifc.flow_status_set_ready_for_mb_processing();
}
// Decrypt the UDS
Self::decrypt_uds(env, KEY_ID_UDS)?;
// Decrypt the Field Entropy
Self::decrypt_field_entropy(env, KEY_ID_FE)?;
// Clear Deobfuscation Engine Secrets
Self::clear_doe_secrets(env)?;
// Derive the DICE CDI from decrypted UDS
Self::derive_cdi(env, KEY_ID_UDS, KEY_ID_ROM_FMC_CDI)?;
// Run the OCP LOCK Flow while the DICE CDI is available.
ocp_lock::ocp_lock_cold_reset_flow(env)?;
// Derive DICE ECC and MLDSA Key Pairs from CDI
let (ecc_key_pair, mldsa_key_pair) = Self::derive_key_pair(
env,
KEY_ID_ROM_FMC_CDI,
KEY_ID_IDEVID_ECDSA_PRIV_KEY,
KEY_ID_IDEVID_MLDSA_KEYPAIR_SEED,
)?;
// Generate the Subject Serial Number and Subject Key Identifier for ECC.
// This information will be used by next DICE Layer while generating
// certificates
let ecc_subj_sn = x509::subj_sn(&mut env.sha256, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_sn =
x509::subj_sn(&mut env.sha256, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(IDevIdSubjIdSnGenerationComplete.into());
let ecc_subj_key_id =
cold_reset::x509::idev_subj_key_id(env, &PubKey::Ecc(&ecc_key_pair.pub_key))?;
let mldsa_subj_key_id =
cold_reset::x509::idev_subj_key_id(env, &PubKey::Mldsa(&mldsa_key_pair.pub_key))?;
report_boot_status(IDevIdSubjKeyIdGenerationComplete.into());
// Generate the output for next layer
let output = DiceOutput {
ecc_subj_key_pair: ecc_key_pair,
ecc_subj_sn,
ecc_subj_key_id,
mldsa_subj_key_id,
mldsa_subj_key_pair: mldsa_key_pair,
mldsa_subj_sn,
};
// Generate the Initial DevID Certificate Signing Request (CSR)
Self::generate_csrs(env, &output)?;
// Indicate (if not already done) to SOC that it can start uploading the firmware image to the mailbox.
if !env.soc_ifc.flow_status_ready_for_mb_processing() {
env.soc_ifc.flow_status_set_ready_for_mb_processing();
}
// Write IDevID public key to FHT
env.persistent_data
.get_mut()
.rom
.fht
.idev_dice_ecdsa_pub_key = output.ecc_subj_key_pair.pub_key;
// Copy the MLDSA public key to Persistent Data.
env.persistent_data.get_mut().rom.idevid_mldsa_pub_key = output.mldsa_subj_key_pair.pub_key;
cprintln!("[idev] --");
report_boot_status(IDevIdDerivationComplete.into());
// Return the DICE Layer Output
Ok(output)
}
/// Decrypt Unique Device Secret (UDS)
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `uds` - Key Vault slot to store the decrypted UDS in
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn decrypt_uds(env: &mut RomEnv, uds: KeyId) -> CaliptraResult<()> {
// Engage the Deobfuscation Engine to decrypt the UDS
env.doe.decrypt_uds(&DOE_IV, uds)?;
report_boot_status(IDevIdDecryptUdsComplete.into());
Ok(())
}
/// Decrypt Field Entropy (FW)
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `slot` - Key Vault slot to store the decrypted UDS in
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn decrypt_field_entropy(env: &mut RomEnv, fe: KeyId) -> CaliptraResult<()> {
// Engage the Deobfuscation Engine to decrypt the UDS
env.doe.decrypt_field_entropy(&DOE_IV, fe)?;
report_boot_status(IDevIdDecryptFeComplete.into());
Ok(())
}
/// Clear Deobfuscation Engine secrets
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn clear_doe_secrets(env: &mut RomEnv) -> CaliptraResult<()> {
let result = env.doe.clear_secrets();
if result.is_ok() {
report_boot_status(IDevIdClearDoeSecretsComplete.into());
}
result
}
/// Derive Composite Device Identity (CDI) from Unique Device Secret (UDS)
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `uds` - Key slot holding the UDS
/// * `cdi` - Key Slot to store the generated CDI
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_cdi(env: &mut RomEnv, uds: KeyId, cdi: KeyId) -> CaliptraResult<()> {
Crypto::hmac_kdf(
&mut env.hmac,
&mut env.trng,
uds,
b"idevid_cdi",
None,
cdi,
HmacMode::Hmac512,
KeyUsage::default()
.set_ecc_key_gen_seed_en()
.set_mldsa_key_gen_seed_en()
.set_hmac_key_en(),
)?;
cprintln!("[idev] Erasing UDS.KEYID = {}", uds as u8);
env.key_vault.erase_key(uds)?;
report_boot_status(IDevIdCdiDerivationComplete.into());
Ok(())
}
/// Derive Dice Layer ECC and MLDSA Key Pairs
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `cdi` - Composite Device Identity
/// * `ecc_priv_key` - Key slot to store the ECC private key into
/// * `mldsa_keypair_seed` - Key slot to store the MLDSA key pair seed
///
/// # Returns
///
/// * `(Ecc384KeyPair, MlDsaKeyPair)` - DICE Layer ECC and MLDSA Key Pairs
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn derive_key_pair(
env: &mut RomEnv,
cdi: KeyId,
ecc_priv_key: KeyId,
mldsa_keypair_seed: KeyId,
) -> CaliptraResult<(Ecc384KeyPair, MlDsaKeyPair)> {
let result = Crypto::ecc384_key_gen(
&mut env.ecc384,
&mut env.hmac,
&mut env.trng,
&mut env.key_vault,
cdi,
b"idevid_ecc_key",
ecc_priv_key,
);
if cfi_launder(result.is_ok()) {
cfi_assert!(result.is_ok());
} else {
cfi_assert!(result.is_err());
}
let ecc_keypair = result?;
// Derive the MLDSA Key Pair.
let result = Crypto::mldsa87_key_gen(
&mut env.mldsa87,
&mut env.hmac,
&mut env.trng,
cdi,
b"idevid_mldsa_key",
mldsa_keypair_seed,
);
if cfi_launder(result.is_ok()) {
cfi_assert!(result.is_ok());
} else {
cfi_assert!(result.is_err());
}
let mldsa_keypair = result?;
report_boot_status(IDevIdKeyPairDerivationComplete.into());
Ok((ecc_keypair, mldsa_keypair))
}
/// Generate Local Device ID CSRs
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `output` - DICE Output
// Inlined to reduce ROM size
#[inline(always)]
fn generate_csrs(env: &mut RomEnv, output: &DiceOutput) -> CaliptraResult<()> {
//
// Generate the CSR if requested via Manufacturing Service Register
//
// A flag is asserted via JTAG interface to enable the generation of CSR
if !env.soc_ifc.mfg_flag_gen_idev_id_csr() {
Self::reset_persistent_storage_csrs(env)?;
return Ok(());
}
// Generate the CSR
Self::make_csr_envelop(env, output)
}
/// Create Initial Device ID CSR Envelope
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `output` - DICE Output
fn make_csr_envelop(env: &mut RomEnv, output: &DiceOutput) -> CaliptraResult<()> {
// Generate ECC CSR.
Self::make_ecc_csr(env, output)?;
// Generate MLDSA CSR.
Self::make_mldsa_csr(env, output)?;
// Create a HMAC tag for the CSR Envelop.
let csr_envelop = &mut env.persistent_data.get_mut().rom.idevid_csr_envelop;
// Data to be HMACed is everything before the CSR MAC.
let offset = offset_of!(InitDevIdCsrEnvelope, csr_mac);
let envlope_slice = csr_envelop
.as_bytes()
.get(..offset)
.ok_or(CaliptraError::ROM_IDEVID_INVALID_CSR)?;
// Generate the CSR MAC.
let mut tag = Array4x16::default();
env.hmac.hmac(
HmacKey::CsrMode(),
HmacData::Slice(envlope_slice),
&mut env.trng,
(&mut tag).into(),
HmacMode::Hmac512,
)?;
// Copy the tag to the CSR envelop.
csr_envelop.csr_mac = tag.into();
// Execute Send CSR Flow
Self::send_csr_envelop(env)?;
report_boot_status(IDevIdMakeCsrEnvelopeComplete.into());
Ok(())
}
fn make_ecc_csr(env: &mut RomEnv, output: &DiceOutput) -> CaliptraResult<()> {
let key_pair = &output.ecc_subj_key_pair;
// CSR `To Be Signed` Parameters
let params = InitDevIdCsrTbsEcc384Params {
// Unique Endpoint Identifier
ueid: &x509::ueid(&env.soc_ifc)?,
// Subject Name
subject_sn: &output.ecc_subj_sn,
// Public Key
public_key: &key_pair.pub_key.to_der(),
};
// Generate the `To Be Signed` portion of the CSR
let tbs = InitDevIdCsrTbsEcc384::new(¶ms);
cprintln!(
"[idev] ECC Sign CSR w/ SUBJECT.KEYID = {}",
key_pair.priv_key as u8
);
// Sign the `To Be Signed` portion
let mut sig = Crypto::ecdsa384_sign_and_verify(
&mut env.sha2_512_384,
&mut env.ecc384,
&mut env.trng,
key_pair.priv_key,
&key_pair.pub_key,
tbs.tbs(),
);
let sig = okmutref(&mut sig)?;
let _pub_x: [u8; 48] = key_pair.pub_key.x.into();
let _pub_y: [u8; 48] = key_pair.pub_key.y.into();
cprintln!("[idev] ECC PUB.X = {}", HexBytes(&_pub_x));
cprintln!("[idev] ECC PUB.Y = {}", HexBytes(&_pub_y));
let _sig_r: [u8; 48] = (&sig.r).into();
let _sig_s: [u8; 48] = (&sig.s).into();
cprintln!("[idev] ECC SIG.R = {}", HexBytes(&_sig_r));
cprintln!("[idev] ECC SIG.S = {}", HexBytes(&_sig_s));
// Build the CSR with `To Be Signed` & `Signature`
let csr_envelop = &mut env.persistent_data.get_mut().rom.idevid_csr_envelop;
let ecdsa384_sig = sig.to_ecdsa();
let result = Ecdsa384CsrBuilder::new(tbs.tbs(), &ecdsa384_sig)
.ok_or(CaliptraError::ROM_IDEVID_CSR_BUILDER_INIT_FAILURE);
sig.zeroize();
let csr_bldr = result?;
let csr_len = csr_bldr
.build(&mut csr_envelop.ecc_csr.csr)
.ok_or(CaliptraError::ROM_IDEVID_CSR_BUILDER_BUILD_FAILURE)?;
if csr_len > csr_envelop.ecc_csr.csr.len() {
return Err(CaliptraError::ROM_IDEVID_CSR_OVERFLOW);
}
csr_envelop.ecc_csr.csr_len = csr_len as u32;
cprintln!(
"[idev] ECC CSR = {}",
HexBytes(&csr_envelop.ecc_csr.csr[..csr_len])
);
Ok(())
}
fn make_mldsa_csr(env: &mut RomEnv, output: &DiceOutput) -> CaliptraResult<()> {
let key_pair = &output.mldsa_subj_key_pair;
let params = InitDevIdCsrTbsMlDsa87Params {
// Unique Endpoint Identifier
ueid: &x509::ueid(&env.soc_ifc)?,
// Subject Name
subject_sn: &output.mldsa_subj_sn,
// Public Key
public_key: &key_pair.pub_key.into(),
};
// Generate the `To Be Signed` portion of the CSR
let tbs = InitDevIdCsrTbsMlDsa87::new(¶ms);
cprintln!(
"[idev] MLDSA Sign CSR w/ SUBJECT.KEYID = {}",
key_pair.key_pair_seed as u8
);
// Sign the `To Be Signed` portion
let mut sig = Crypto::mldsa87_sign_and_verify(
&mut env.mldsa87,
&mut env.trng,
key_pair.key_pair_seed,
&key_pair.pub_key,
tbs.tbs(),
)?;
// Build the CSR with `To Be Signed` & `Signature`
let mldsa87_signature = caliptra_x509::MlDsa87Signature {
sig: sig.as_bytes()[..4627].try_into().unwrap(),
};
let csr_envelop = &mut env.persistent_data.get_mut().rom.idevid_csr_envelop;
let result = MlDsa87CsrBuilder::new(tbs.tbs(), &mldsa87_signature)
.ok_or(CaliptraError::ROM_IDEVID_CSR_BUILDER_INIT_FAILURE);
sig.zeroize();
let csr_bldr = result?;
let csr_len = csr_bldr
.build(&mut csr_envelop.mldsa_csr.csr)
.ok_or(CaliptraError::ROM_IDEVID_CSR_BUILDER_BUILD_FAILURE)?;
if csr_len > csr_envelop.mldsa_csr.csr.len() {
return Err(CaliptraError::ROM_IDEVID_CSR_OVERFLOW);
}
csr_envelop.mldsa_csr.csr_len = csr_len as u32;
Ok(())
}
fn reset_persistent_storage_csrs(env: &mut RomEnv) -> CaliptraResult<()> {
let csr_envelop_persistent_mem = &mut env.persistent_data.get_mut().rom.idevid_csr_envelop;
*csr_envelop_persistent_mem = InitDevIdCsrEnvelope::default();
Ok(())
}
/// Send Initial Device ID CSR to SOC
///
/// # Argument
///
/// * `env` - ROM Environment
fn send_csr_envelop(env: &mut RomEnv) -> CaliptraResult<()> {
let csr_envelop = &env.persistent_data.get().rom.idevid_csr_envelop;
loop {
// Create Mailbox send transaction to send the CSR envelop
if let Some(mut txn) = env.mbox.try_start_send_txn() {
// Copy the CSR to mailbox
txn.send_request(0, csr_envelop.as_bytes())?;
// Signal the JTAG/SOC that Initial Device ID CSR envelop is ready
env.soc_ifc.flow_status_set_idevid_csr_ready();
// Wait for JTAG/SOC to consume the mailbox
while env.soc_ifc.mfg_flag_gen_idev_id_csr() {}
// Release access to the mailbox
txn.complete()?;
report_boot_status(IDevIdSendCsrEnvelopeComplete.into());
// exit the loop
break Ok(());
}
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/x509.rs | rom/dev/src/flow/cold_reset/x509.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
x509.rs
Abstract:
File contains X509 Certificate & CSR related utility functions
--*/
use crate::cprintln;
use crate::rom_env::RomEnv;
use caliptra_common::{crypto::PubKey, x509};
use caliptra_drivers::*;
use core::mem::size_of;
/// Get Initial Device ID Cert Subject Key Identifier
///
/// # Arguments
///
/// * `env` - ROM Environment
/// * `pub_key` - ECC or MLDSA Public Key
///
/// # Returns
///
/// `[u8; 20]` - X509 Subject Key Identifier
pub fn idev_subj_key_id(env: &mut RomEnv, pub_key: &PubKey) -> CaliptraResult<[u8; 20]> {
let mut pub_key_bytes: [u8; size_of::<Mldsa87PubKey>()] = [0; size_of::<Mldsa87PubKey>()];
let pub_key_size = x509::get_pubkey_bytes(pub_key, &mut pub_key_bytes);
let data: &[u8] = &pub_key_bytes[..pub_key_size];
let ecc_pub_key = matches!(pub_key, PubKey::Ecc(_));
let digest: [u8; 20] = match env
.soc_ifc
.fuse_bank()
.idev_id_x509_key_id_algo(ecc_pub_key)
{
X509KeyIdAlgo::Sha1 => {
cprintln!("[idev] Sha1 KeyId Algorithm");
let digest = env.sha1.digest(data);
okref(&digest)?.into()
}
X509KeyIdAlgo::Sha256 => {
cprintln!("[idev] Sha256 KeyId Algorithm");
let digest = env.sha256.digest(data);
let digest: [u8; 32] = okref(&digest)?.into();
digest[..20].try_into().unwrap()
}
X509KeyIdAlgo::Sha384 => {
cprintln!("[idev] Sha384 KeyId Algorithm");
let digest = env.sha2_512_384.sha384_digest(data);
let digest: [u8; 48] = okref(&digest)?.into();
digest[..20].try_into().unwrap()
}
X509KeyIdAlgo::Sha512 => {
cprintln!("[idev] Sha512 KeyId Algorithm");
let digest = env.sha2_512_384.sha512_digest(data);
let digest: [u8; 64] = okref(&digest)?.into();
digest[..20].try_into().unwrap()
}
X509KeyIdAlgo::Fuse => {
cprintln!("[idev] Fuse KeyId");
env.soc_ifc.fuse_bank().subject_key_id(ecc_pub_key)
}
};
Ok(digest)
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/cm_derive_stable_key.rs | rom/dev/src/flow/cold_reset/fw_processor/cm_derive_stable_key.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
cm_derive_stable_key.rs
Abstract:
File contains CM_DERIVE_STABLE_KEY mailbox command.
--*/
use caliptra_api::mailbox::{CmDeriveStableKeyReq, CmDeriveStableKeyResp};
use caliptra_drivers::{Aes, CaliptraResult, Hmac, PersistentData, Trng};
use zerocopy::{transmute, FromBytes, IntoBytes};
use super::FirmwareProcessor;
pub struct CmDeriveStableKeyCmd;
impl CmDeriveStableKeyCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
aes: &mut Aes,
hmac: &mut Hmac,
trng: &mut Trng,
persistent_data: &mut PersistentData,
resp: &mut [u8],
) -> CaliptraResult<usize> {
let request = CmDeriveStableKeyReq::ref_from_bytes(cmd_bytes)
.map_err(|_| caliptra_drivers::CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let encrypted_cmk =
FirmwareProcessor::derive_stable_key(aes, hmac, trng, persistent_data, request)?;
// Use the response buffer directly as CmDeriveStableKeyResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<CmDeriveStableKeyResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(caliptra_drivers::CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let derive_resp = CmDeriveStableKeyResp::mut_from_bytes(resp)
.map_err(|_| caliptra_drivers::CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
derive_resp.cmk = transmute!(encrypted_cmk);
let resp_bytes = derive_resp.as_bytes();
Ok(resp_bytes.len())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/ri_download_firmware.rs | rom/dev/src/flow/cold_reset/fw_processor/ri_download_firmware.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
ri_download_firmware.rs
Abstract:
File contains RI_DOWNLOAD_FIRMWARE mailbox command.
--*/
use caliptra_common::RomBootStatus::FwProcessorDownloadImageComplete;
use caliptra_drivers::{cprintln, report_boot_status, CaliptraResult, Dma, SocIfc};
use super::FirmwareProcessor;
pub struct RiDownloadFirmwareCmd;
impl RiDownloadFirmwareCmd {
#[inline(always)]
pub(crate) fn execute(dma: &mut Dma, soc_ifc: &mut SocIfc) -> CaliptraResult<u32> {
// Download the firmware image from the recovery interface.
cprintln!("[fwproc] Downloading image from RRI to MCU SRAM");
let image_size_bytes =
FirmwareProcessor::retrieve_image_from_recovery_interface_to_mcu(dma, soc_ifc)?;
cprintln!(
"[fwproc] Received image from the Recovery Interface of size {} bytes",
image_size_bytes
);
report_boot_status(FwProcessorDownloadImageComplete.into());
Ok(image_size_bytes)
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/shutdown.rs | rom/dev/src/flow/cold_reset/fw_processor/shutdown.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
shutdown.rs
Abstract:
File contains SHUTDOWN mailbox command.
--*/
use caliptra_common::mailbox_api::{MailboxReqHeader, MailboxRespHeader};
use caliptra_drivers::{CaliptraError, CaliptraResult};
use zerocopy::FromBytes;
pub struct ShutdownCmd;
impl ShutdownCmd {
#[inline(always)]
pub(crate) fn execute(cmd_bytes: &[u8], _resp: &mut [u8]) -> CaliptraResult<usize> {
MailboxReqHeader::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
// Zero value of response buffer is good
Ok(core::mem::size_of::<MailboxRespHeader>())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/version.rs | rom/dev/src/flow/cold_reset/fw_processor/version.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
version.rs
Abstract:
File contains VERSION mailbox command.
--*/
use caliptra_common::fips::FipsVersionCmd;
use caliptra_common::mailbox_api::{FipsVersionResp, MailboxReqHeader};
use caliptra_drivers::{CaliptraError, CaliptraResult, SocIfc};
use zerocopy::{FromBytes, IntoBytes};
pub struct VersionCmd;
impl VersionCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
soc_ifc: &mut SocIfc,
resp: &mut [u8],
) -> CaliptraResult<usize> {
MailboxReqHeader::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
// Use the response buffer directly as FipsVersionResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<FipsVersionResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let version_resp = FipsVersionResp::mut_from_bytes(resp)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let version_data = FipsVersionCmd::execute(soc_ifc);
version_resp.hdr = version_data.hdr;
version_resp.mode = version_data.mode;
version_resp.fips_rev = version_data.fips_rev;
version_resp.name = version_data.name;
let resp_bytes = version_resp.as_bytes();
Ok(resp_bytes.len())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/zeroize_uds_fe.rs | rom/dev/src/flow/cold_reset/fw_processor/zeroize_uds_fe.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
zeroize_uds_fe.rs
Abstract:
File contains ZEROIZE_UDS_FE mailbox command.
--*/
use caliptra_api::mailbox::{
ZeroizeUdsFeReq, ZeroizeUdsFeResp, ZEROIZE_FE0_FLAG, ZEROIZE_FE1_FLAG, ZEROIZE_FE2_FLAG,
ZEROIZE_FE3_FLAG, ZEROIZE_UDS_FLAG,
};
use caliptra_common::mailbox_api::MailboxRespHeader;
use caliptra_common::uds_fe_programming::UdsFeProgrammingFlow;
use caliptra_drivers::{CaliptraError, CaliptraResult, Dma, SocIfc};
use zerocopy::{FromBytes, IntoBytes};
pub struct ZeroizeUdsFeCmd;
impl ZeroizeUdsFeCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
soc_ifc: &mut SocIfc,
dma: &mut Dma,
resp: &mut [u8],
) -> CaliptraResult<usize> {
let request = ZeroizeUdsFeReq::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let result = (|| -> CaliptraResult<()> {
// Zeroize UDS partition
if request.flags & ZEROIZE_UDS_FLAG != 0 {
let uds_flow = UdsFeProgrammingFlow::Uds;
uds_flow.zeroize(soc_ifc, dma)?;
}
// Zeroize FE partitions (0-3)
const FE_FLAGS: [u32; 4] = [
ZEROIZE_FE0_FLAG,
ZEROIZE_FE1_FLAG,
ZEROIZE_FE2_FLAG,
ZEROIZE_FE3_FLAG,
];
for (partition, &flag) in FE_FLAGS.iter().enumerate() {
if request.flags & flag != 0 {
let fe_flow = UdsFeProgrammingFlow::Fe {
partition: partition as u32,
};
fe_flow.zeroize(soc_ifc, dma)?;
}
}
Ok(())
})();
// Use the response buffer directly as ZeroizeUdsFeResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<ZeroizeUdsFeResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let zeroize_resp = ZeroizeUdsFeResp::mut_from_bytes(resp)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
zeroize_resp.hdr = MailboxRespHeader::default();
zeroize_resp.dpe_result = match result {
Ok(()) => 0, // NoError
Err(_) => 0x1, // InternalError
};
let resp_bytes = zeroize_resp.as_bytes();
Ok(resp_bytes.len())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/cm_hmac.rs | rom/dev/src/flow/cold_reset/fw_processor/cm_hmac.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
cm_hmac.rs
Abstract:
File contains CM_HMAC mailbox command.
--*/
use caliptra_api::mailbox::CmHmacResp;
use caliptra_common::crypto::Crypto;
use caliptra_common::hmac_cm::hmac;
use caliptra_common::mailbox_api::ResponseVarSize;
use caliptra_drivers::{Aes, CaliptraError, CaliptraResult, Hmac, PersistentData, Trng};
use zerocopy::{FromBytes, IntoBytes};
pub struct CmHmacCmd;
impl CmHmacCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
aes: &mut Aes,
hmac_engine: &mut Hmac,
trng: &mut Trng,
persistent_data: &mut PersistentData,
resp: &mut [u8],
) -> CaliptraResult<usize> {
// Use the response buffer directly as CmHmacResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<CmHmacResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let hmac_resp = CmHmacResp::mut_from_bytes(resp)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
hmac(
hmac_engine,
aes,
trng,
Crypto::get_cmb_aes_key(persistent_data),
cmd_bytes,
hmac_resp.as_mut_bytes(),
)?;
let resp_bytes = hmac_resp.as_bytes_partial()?;
Ok(resp_bytes.len())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/mldsa_verify.rs | rom/dev/src/flow/cold_reset/fw_processor/mldsa_verify.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
mldsa_verify.rs
Abstract:
File contains MLDSA87_SIGNATURE_VERIFY mailbox command.
--*/
use caliptra_common::mailbox_api::MailboxRespHeader;
use caliptra_drivers::{report_fw_error_non_fatal, CaliptraResult, Mldsa87};
pub struct MldsaVerifyCmd;
impl MldsaVerifyCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
mldsa87: &mut Mldsa87,
_resp: &mut [u8],
) -> CaliptraResult<usize> {
let result = caliptra_common::verify::MldsaVerifyCmd::execute(mldsa87, cmd_bytes);
match result {
Ok(_) => {
// Zero value of response buffer is good
Ok(core::mem::size_of::<MailboxRespHeader>())
}
Err(e) => {
report_fw_error_non_fatal(e.into());
// Return 0 to indicate failure
Ok(0)
}
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/stash_measurement.rs | rom/dev/src/flow/cold_reset/fw_processor/stash_measurement.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
stash_measurement.rs
Abstract:
File contains STASH_MEASUREMENT mailbox command.
--*/
use caliptra_common::mailbox_api::{StashMeasurementReq, StashMeasurementResp};
use caliptra_common::pcr::PCR_ID_STASH_MEASUREMENT;
use caliptra_common::{PcrLogEntry, PcrLogEntryId};
use caliptra_drivers::pcr_log::MeasurementLogEntry;
use caliptra_drivers::{CaliptraError, CaliptraResult, PcrBank, PersistentData, Sha2_512_384};
use zerocopy::{FromBytes, IntoBytes};
pub struct StashMeasurementCmd;
impl StashMeasurementCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
pcr_bank: &mut PcrBank,
sha2_512_384: &mut Sha2_512_384,
persistent_data: &mut PersistentData,
_resp: &mut [u8],
) -> CaliptraResult<usize> {
let measurement = StashMeasurementReq::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
// Extend measurement into PCR31.
Self::extend_measurement(pcr_bank, sha2_512_384, persistent_data, measurement)?;
// Zero value of response buffer is good
Ok(core::mem::size_of::<StashMeasurementResp>())
}
/// Extends measurement into PCR31 and logs it to PCR log.
///
/// # Arguments
/// * `pcr_bank` - PCR Bank
/// * `sha2_512_384` - SHA384
/// * `persistent_data` - Persistent data
/// * `stash_measurement` - Measurement
///
/// # Returns
/// * `()` - Ok
/// Error code on failure.
fn extend_measurement(
pcr_bank: &mut PcrBank,
sha2: &mut Sha2_512_384,
persistent_data: &mut PersistentData,
stash_measurement: &StashMeasurementReq,
) -> CaliptraResult<()> {
// Extend measurement into PCR31.
pcr_bank.extend_pcr(
PCR_ID_STASH_MEASUREMENT,
sha2,
stash_measurement.measurement.as_bytes(),
)?;
// Log measurement to the measurement log.
Self::log_measurement(persistent_data, stash_measurement)
}
/// Log measurement data to the Stash Measurement log
///
/// # Arguments
/// * `persistent_data` - Persistent data
/// * `stash_measurement` - Measurement
///
/// # Return Value
/// * `Ok(())` - Success
/// * `Err(GlobalErr::MeasurementLogExhausted)` - Measurement log exhausted
///
fn log_measurement(
persistent_data: &mut PersistentData,
stash_measurement: &StashMeasurementReq,
) -> CaliptraResult<()> {
let fht = &mut persistent_data.rom.fht;
let Some(dst) = persistent_data
.rom
.measurement_log
.get_mut(fht.meas_log_index as usize)
else {
return Err(CaliptraError::ROM_GLOBAL_MEASUREMENT_LOG_EXHAUSTED);
};
*dst = MeasurementLogEntry {
pcr_entry: PcrLogEntry {
id: PcrLogEntryId::StashMeasurement as u16,
reserved0: [0u8; 2],
pcr_ids: 1 << (PCR_ID_STASH_MEASUREMENT as u8),
pcr_data: zerocopy::transmute!(stash_measurement.measurement),
},
metadata: stash_measurement.metadata,
context: zerocopy::transmute!(stash_measurement.context),
svn: stash_measurement.svn,
reserved0: [0u8; 4],
};
fht.meas_log_index += 1;
Ok(())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/mod.rs | rom/dev/src/flow/cold_reset/fw_processor/mod.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
mod.rs
Abstract:
File contains the code to download and validate the firmware.
--*/
#[cfg(feature = "fake-rom")]
use crate::flow::fake::FakeRomImageVerificationEnv;
use crate::fuse::log_fuse_data;
use crate::key_ladder;
use crate::pcr;
use crate::rom_env::RomEnv;
use caliptra_api::mailbox;
use caliptra_api::mailbox::MailboxRespHeader;
use caliptra_api::mailbox::{
AlgorithmType, CmDeriveStableKeyReq, CmKeyUsage, CmStableKeyType, CM_STABLE_KEY_INFO_SIZE_BYTES,
};
#[cfg(not(feature = "no-cfi"))]
use caliptra_cfi_derive::cfi_impl_fn;
use caliptra_cfi_lib::{cfi_assert_bool, cfi_assert_ne, CfiCounter};
use caliptra_common::{
crypto::{Crypto, EncryptedCmk, UnencryptedCmk},
mailbox_api::{CommandId, MailboxReqHeader, ZeroizeUdsFeResp},
verifier::FirmwareImageVerificationEnv,
FuseLogEntryId,
RomBootStatus::*,
};
use caliptra_drivers::*;
use caliptra_image_types::{FwVerificationPqcKeyType, ImageManifest, IMAGE_BYTE_SIZE};
use caliptra_image_verify::{
ImageVerificationInfo, ImageVerificationLogInfo, ImageVerifier, MAX_FIRMWARE_SVN,
};
use caliptra_kat::KatsEnv;
use caliptra_x509::{NotAfter, NotBefore};
use core::mem::{size_of, ManuallyDrop};
use dma::AesDmaMode;
use zerocopy::{FromBytes, IntoBytes};
use zeroize::Zeroize;
use crate::flow::cold_reset::ocp_lock;
mod capabilities;
mod cm_derive_stable_key;
mod cm_hmac;
mod cm_random_generate;
mod ecdsa_verify;
mod get_idev_csr;
mod get_ldev_cert;
mod install_owner_pk_hash;
mod mldsa_verify;
mod report_hek_metadata;
mod ri_download_firmware;
mod self_test;
mod shutdown;
mod stash_measurement;
mod version;
mod zeroize_uds_fe;
use capabilities::CapabilitiesCmd;
use cm_derive_stable_key::CmDeriveStableKeyCmd;
use cm_hmac::CmHmacCmd;
use cm_random_generate::CmRandomGenerateCmd;
use ecdsa_verify::EcdsaVerifyCmd;
use get_idev_csr::{GetIdevEcc384CsrCmd, GetIdevMldsa87CsrCmd};
use get_ldev_cert::GetLdevCertCmd;
use install_owner_pk_hash::InstallOwnerPkHashCmd;
use mldsa_verify::MldsaVerifyCmd;
use report_hek_metadata::OcpLockReportHekMetadataCmd;
use ri_download_firmware::RiDownloadFirmwareCmd;
use self_test::{SelfTestGetResultsCmd, SelfTestStartCmd};
use shutdown::ShutdownCmd;
use stash_measurement::StashMeasurementCmd;
use version::VersionCmd;
use zeroize_uds_fe::ZeroizeUdsFeCmd;
const RESERVED_PAUSER: u32 = 0xFFFFFFFF;
#[derive(Debug, Default, Zeroize)]
pub struct FwProcInfo {
pub fmc_cert_valid_not_before: NotBefore,
pub fmc_cert_valid_not_after: NotAfter,
pub effective_fuse_svn: u32,
pub owner_pub_keys_digest_in_fuses: bool,
pub pqc_key_type: u8,
}
pub struct FirmwareProcessor {}
impl FirmwareProcessor {
pub fn process(env: &mut RomEnv) -> CaliptraResult<FwProcInfo> {
let mut kats_env = caliptra_kat::KatsEnv {
// SHA1 Engine
sha1: &mut env.sha1,
// sha256
sha256: &mut env.sha256,
// SHA2-512/384 Engine
sha2_512_384: &mut env.sha2_512_384,
// SHA2-512/384 Accelerator
sha2_512_384_acc: &mut env.sha2_512_384_acc,
// SHA3/SHAKE Engine
sha3: &mut env.sha3,
// Hmac-512/384 Engine
hmac: &mut env.hmac,
// Cryptographically Secure Random Number Generator
trng: &mut env.trng,
// LMS Engine
lms: &mut env.lms,
// Mldsa87 Engine
mldsa87: &mut env.mldsa87,
// Ecc384 Engine
ecc384: &mut env.ecc384,
// AES Engine
aes: &mut env.aes,
// SHA Acc lock state
sha_acc_lock_state: ShaAccLockState::NotAcquired,
};
// Process mailbox commands.
let (mut txn, image_size_bytes) = Self::process_mailbox_commands(
&mut env.soc_ifc,
&mut env.mbox,
&mut env.pcr_bank,
&mut env.dma,
&mut kats_env,
env.persistent_data.get_mut(),
)?;
// After processing commands but before booting into the next stage we need to complete the OCP LOCK flow.
if env.soc_ifc.ocp_lock_enabled() {
ocp_lock::complete_ocp_lock_flow(
&mut env.soc_ifc,
env.persistent_data.get_mut(),
&mut env.key_vault,
)?;
}
#[cfg(feature = "fips-test-hooks")]
unsafe {
caliptra_drivers::FipsTestHook::halt_if_hook_set(
caliptra_drivers::FipsTestHook::HALT_FW_LOAD,
)
};
// Load the manifest into DCCM.
let manifest = Self::load_manifest(
&mut env.persistent_data,
txn.as_deref_mut(),
&mut env.soc_ifc,
&mut env.dma,
);
let manifest = okref(&manifest)?;
let image_source = if let Some(ref txn) = txn {
caliptra_common::verifier::ImageSource::MboxMemory(txn.raw_mailbox_contents())
} else {
caliptra_common::verifier::ImageSource::McuSram(&env.dma)
};
let mut venv = FirmwareImageVerificationEnv {
sha256: &mut env.sha256,
sha2_512_384: &mut env.sha2_512_384,
sha2_512_384_acc: &mut env.sha2_512_384_acc,
soc_ifc: &mut env.soc_ifc,
ecc384: &mut env.ecc384,
mldsa87: &mut env.mldsa87,
data_vault: &env.persistent_data.get().rom.data_vault,
pcr_bank: &mut env.pcr_bank,
image_source,
persistent_data: env.persistent_data.get(),
};
// Verify the image
let info = Self::verify_image(&mut venv, manifest, image_size_bytes);
let info = okref(&info)?;
Self::update_fuse_log(
&mut env.persistent_data.get_mut().rom.fuse_log,
&info.log_info,
)?;
// Populate data vault
Self::populate_data_vault(info, &mut env.persistent_data);
// Extend PCR0 and PCR1
pcr::extend_pcrs(
env.persistent_data.get_mut(),
&env.soc_ifc,
&mut env.pcr_bank,
&mut env.sha2_512_384,
info,
)?;
report_boot_status(FwProcessorExtendPcrComplete.into());
// Load the image
Self::load_image(manifest, txn.as_deref_mut(), &mut env.soc_ifc, &mut env.dma)?;
// Complete the mailbox transaction indicating success.
if let Some(ref mut txn) = txn {
txn.complete(true)?;
}
report_boot_status(FwProcessorFirmwareDownloadTxComplete.into());
// Update FW version registers
// Truncate FMC version to 16 bits (no error for 31:16 != 0)
env.soc_ifc.set_fmc_fw_rev_id(manifest.fmc.version as u16);
env.soc_ifc.set_rt_fw_rev_id(manifest.runtime.version);
// Get the certificate validity info
let (nb, nf) = Self::get_cert_validity_info(manifest);
Self::populate_fw_key_ladder(env)?;
report_boot_status(FwProcessorComplete.into());
Ok(FwProcInfo {
fmc_cert_valid_not_before: nb,
fmc_cert_valid_not_after: nf,
effective_fuse_svn: info.effective_fuse_svn,
owner_pub_keys_digest_in_fuses: info.owner_pub_keys_digest_in_fuses,
pqc_key_type: info.pqc_key_type as u8,
})
}
/// Process mailbox commands
///
/// # Arguments
///
/// * `soc_ifc` - SOC Interface
/// * `mbox` - Mailbox
/// * `pcr_bank` - PCR Bank
/// * `dma` - DMA engine
/// * `env` - KAT Environment
/// * `persistent_data` - Persistent data
///
/// # Returns
/// * `Option<MailboxRecvTxn>` - Mailbox Receive Transaction (Some in passive mode, None in subsystem mode)
/// * `u32` - Image size in bytes
///
/// In passive mode, the mailbox transaction handle is returned for the FIRMWARE_LOAD command.
/// In subsystem mode, firmware is loaded via the recovery interface and None is returned.
/// This transaction is ManuallyDrop because we don't want the transaction
/// to be completed with failure until after handle_fatal_error is called.
/// This prevents a race condition where the SoC reads FW_ERROR_NON_FATAL
/// immediately after the mailbox transaction fails,
/// but before caliptra has set the FW_ERROR_NON_FATAL register.
fn process_mailbox_commands<'a>(
soc_ifc: &mut SocIfc,
mbox: &'a mut Mailbox,
pcr_bank: &mut PcrBank,
dma: &mut Dma,
env: &mut KatsEnv,
persistent_data: &mut PersistentData,
) -> CaliptraResult<(Option<ManuallyDrop<MailboxRecvTxn<'a>>>, u32)> {
let mut self_test_in_progress = false;
let subsystem_mode = soc_ifc.subsystem_mode();
cprintln!("[fwproc] Wait for Commands...");
loop {
// Random delay for CFI glitch protection.
CfiCounter::delay();
if let Some(txn) = mbox.peek_recv() {
clear_fw_error_non_fatal(persistent_data);
// Drop all commands for invalid PAUSER
if txn.id() == RESERVED_PAUSER {
return Err(CaliptraError::FW_PROC_MAILBOX_RESERVED_PAUSER);
}
cfi_assert_ne(txn.id(), RESERVED_PAUSER);
cprintln!("[fwproc] Recv command 0x{:08x}", txn.cmd());
// Handle FW load as a separate case due to the re-borrow explained below
if txn.cmd() == CommandId::FIRMWARE_LOAD.into() {
if subsystem_mode {
Err(CaliptraError::FW_PROC_MAILBOX_FW_LOAD_CMD_IN_SUBSYSTEM_MODE)?;
}
cfi_assert_bool(!subsystem_mode);
// Re-borrow mailbox to work around https://github.com/rust-lang/rust/issues/54663
let txn = mbox
.peek_recv()
.ok_or(CaliptraError::FW_PROC_MAILBOX_STATE_INCONSISTENT)?;
// This is a download-firmware command; don't drop this, as the
// transaction will be completed by either handle_fatal_error() (on
// failure) or by a manual complete call upon success.
let txn = ManuallyDrop::new(txn.start_txn());
let image_size_bytes = txn.dlen();
if image_size_bytes == 0 || image_size_bytes > IMAGE_BYTE_SIZE as u32 {
cprintln!("Invalid Image of size {} bytes", image_size_bytes);
return Err(CaliptraError::FW_PROC_INVALID_IMAGE_SIZE);
}
cprintln!("[fwproc] Received Image of size {} bytes", image_size_bytes);
report_boot_status(FwProcessorDownloadImageComplete.into());
return Ok((Some(txn), image_size_bytes));
}
// Handle RI_DOWNLOAD_FIRMWARE as a separate case since it needs mutable access to mbox
if txn.cmd() == CommandId::RI_DOWNLOAD_FIRMWARE.into() {
if !subsystem_mode {
cprintln!(
"[fwproc] RI_DOWNLOAD_FIRMWARE cmd not supported in passive mode"
);
// Start and complete the transaction with error
let txn = mbox
.peek_recv()
.ok_or(CaliptraError::FW_PROC_MAILBOX_STATE_INCONSISTENT)?;
let mut txn = txn.start_txn();
txn.complete(false)?;
Err(CaliptraError::FW_PROC_MAILBOX_INVALID_COMMAND)?;
}
cfi_assert_bool(subsystem_mode);
// Complete the command indicating success
cprintln!("[fwproc] Completing RI_DOWNLOAD_FIRMWARE command");
let txn = mbox
.peek_recv()
.ok_or(CaliptraError::FW_PROC_MAILBOX_STATE_INCONSISTENT)?;
let mut txn = txn.start_txn();
txn.complete(true)?;
// Explicitly drop to release the borrow on mbox
drop(txn);
// Now we can access mbox again since the transaction is complete
return Ok((None, RiDownloadFirmwareCmd::execute(dma, soc_ifc)?));
}
// NOTE: We use ManuallyDrop here because any error here becomes a fatal error
// See note above about race condition
let mut txn = ManuallyDrop::new(txn.start_txn());
// Get command bytes and verify checksum
let cmd_bytes = FirmwareProcessor::get_and_verify_cmd_bytes(&txn)?;
// Response buffer
let resp = &mut [0u8; caliptra_common::mailbox_api::MAX_ROM_RESP_SIZE][..];
// Don't read CMD again in the same loop execution is it might already have changed
// to the next CMD
let cmd = txn.cmd();
let resp_len = match CommandId::from(cmd) {
CommandId::VERSION => VersionCmd::execute(cmd_bytes, soc_ifc, resp)?,
CommandId::SELF_TEST_START => {
let (in_progress, len) =
SelfTestStartCmd::execute(cmd_bytes, env, self_test_in_progress, resp)?;
self_test_in_progress = in_progress;
len
}
CommandId::SELF_TEST_GET_RESULTS => {
let (in_progress, len) =
SelfTestGetResultsCmd::execute(cmd_bytes, self_test_in_progress, resp)?;
self_test_in_progress = in_progress;
len
}
CommandId::SHUTDOWN => ShutdownCmd::execute(cmd_bytes, resp)?,
CommandId::CAPABILITIES => CapabilitiesCmd::execute(cmd_bytes, soc_ifc, resp)?,
CommandId::ECDSA384_SIGNATURE_VERIFY => {
EcdsaVerifyCmd::execute(cmd_bytes, env.ecc384, resp)?
}
CommandId::MLDSA87_SIGNATURE_VERIFY => {
MldsaVerifyCmd::execute(cmd_bytes, env.mldsa87, resp)?
}
CommandId::STASH_MEASUREMENT => {
if persistent_data.rom.fht.meas_log_index == MEASUREMENT_MAX_COUNT as u32 {
cprintln!("[fwproc] Max # of measurements received.");
txn.complete(false)?;
// Raise a fatal error on hitting the max. limit.
// This ensures that any SOC ROM/FW couldn't send a stash measurement
// that wasn't properly stored within Caliptra.
return Err(CaliptraError::FW_PROC_MAILBOX_STASH_MEASUREMENT_MAX_LIMIT);
}
StashMeasurementCmd::execute(
cmd_bytes,
pcr_bank,
env.sha2_512_384,
persistent_data,
resp,
)?
}
CommandId::GET_IDEV_ECC384_CSR => {
GetIdevEcc384CsrCmd::execute(cmd_bytes, persistent_data, resp)?
}
CommandId::GET_IDEV_MLDSA87_CSR => {
GetIdevMldsa87CsrCmd::execute(cmd_bytes, persistent_data, resp)?
}
CommandId::CM_DERIVE_STABLE_KEY => CmDeriveStableKeyCmd::execute(
cmd_bytes,
env.aes,
env.hmac,
env.trng,
persistent_data,
resp,
)?,
CommandId::CM_RANDOM_GENERATE => {
CmRandomGenerateCmd::execute(cmd_bytes, env.trng, resp)?
}
CommandId::CM_HMAC => CmHmacCmd::execute(
cmd_bytes,
env.aes,
env.hmac,
env.trng,
persistent_data,
resp,
)?,
CommandId::OCP_LOCK_REPORT_HEK_METADATA => {
OcpLockReportHekMetadataCmd::execute(
cmd_bytes,
soc_ifc,
persistent_data,
resp,
)?
}
CommandId::INSTALL_OWNER_PK_HASH => {
InstallOwnerPkHashCmd::execute(cmd_bytes, persistent_data, resp)?
}
CommandId::GET_LDEV_ECC384_CERT => GetLdevCertCmd::execute(
cmd_bytes,
persistent_data,
AlgorithmType::Ecc384,
resp,
)?,
CommandId::GET_LDEV_MLDSA87_CERT => GetLdevCertCmd::execute(
cmd_bytes,
persistent_data,
AlgorithmType::Mldsa87,
resp,
)?,
CommandId::ZEROIZE_UDS_FE => {
ZeroizeUdsFeCmd::execute(cmd_bytes, soc_ifc, dma, resp)?
}
_ => {
cprintln!("[fwproc] Invalid command received");
// Don't complete the transaction here; let the fatal
// error handler do it to prevent a race condition
// setting the error code.
return Err(CaliptraError::FW_PROC_MAILBOX_INVALID_COMMAND);
}
};
// Send response or complete with failure
if resp_len >= core::mem::size_of::<MailboxRespHeader>() {
let response = resp
.get_mut(..resp_len)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
mailbox::populate_checksum(response);
txn.send_response(response)?;
} else {
// Response length of 0 indicates failure (e.g., self test commands)
txn.complete(false)?;
}
match CommandId::from(cmd) {
// ZEROIZE_UDS_FE sends both a response as well as an error after that.
// Shutdown after zeroization as UDS and/or FE values and its derived keys are no longer valid.
CommandId::ZEROIZE_UDS_FE => {
let resp = ZeroizeUdsFeResp::ref_from_bytes(&resp[..resp_len])
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_PROCESS_FAILURE)?;
// Use the response to figure out if we succeeded or failed
if resp.dpe_result == 0 {
Err(CaliptraError::UDS_FE_PROGRAMMING_ZEROIZATION_SUCCESS)?
} else {
Err(CaliptraError::UDS_FE_PROGRAMMING_ZEROIZATION_FAILED)?
}
}
CommandId::SHUTDOWN =>
// Causing a ROM Fatal Error will zeroize the module
{
Err(CaliptraError::RUNTIME_SHUTDOWN)?
}
_ => (),
};
}
}
}
/// Load the manifest
///
/// # Arguments
///
/// * `persistent_data` - Persistent data accessor
/// * `txn` - Mailbox transaction (Some in passive mode, None in subsystem mode)
/// * `soc_ifc` - SoC Interface
/// * `dma` - DMA engine
///
/// # Returns
///
/// * `Manifest` - Caliptra Image Bundle Manifest
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest(
persistent_data: &mut PersistentDataAccessor,
txn: Option<&mut MailboxRecvTxn>,
soc_ifc: &mut SocIfc,
dma: &mut Dma,
) -> CaliptraResult<ImageManifest> {
if let Some(txn) = txn {
Self::load_manifest_from_mbox(persistent_data, txn)
} else {
Self::load_manifest_from_mcu(persistent_data, soc_ifc, dma)
}
}
/// Load the manifest from mailbox SRAM
///
/// # Returns
///
/// * `Manifest` - Caliptra Image Bundle Manifest
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_mbox(
persistent_data: &mut PersistentDataAccessor,
txn: &mut MailboxRecvTxn,
) -> CaliptraResult<ImageManifest> {
let manifest = &mut persistent_data.get_mut().rom.manifest1;
let mbox_sram = txn.raw_mailbox_contents();
let manifest_buf = manifest.as_mut_bytes();
if mbox_sram.len() < manifest_buf.len() {
Err(CaliptraError::FW_PROC_INVALID_IMAGE_SIZE)?;
}
manifest_buf.copy_from_slice(&mbox_sram[..manifest_buf.len()]);
report_boot_status(FwProcessorManifestLoadComplete.into());
Ok(*manifest)
}
/// Load the manifest from MCU SRAM using DMA
///
/// # Returns
///
/// * `Manifest` - Caliptra Image Bundle Manifest
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_manifest_from_mcu(
persistent_data: &mut PersistentDataAccessor,
soc_ifc: &mut SocIfc,
dma: &mut Dma,
) -> CaliptraResult<ImageManifest> {
let manifest = &mut persistent_data.get_mut().rom.manifest1;
let manifest_buf = manifest.as_mut_bytes();
// Get MCU SRAM address
let mci_base_addr: AxiAddr = soc_ifc.mci_base_addr().into();
let recovery_interface_base_addr: AxiAddr = soc_ifc.recovery_interface_base_addr().into();
let caliptra_base_addr: AxiAddr = soc_ifc.caliptra_base_axi_addr().into();
// Read manifest from MCU SRAM using DMA directly into manifest buffer
let (manifest_words, _) = <[u32]>::mut_from_prefix(manifest_buf).unwrap();
let dma_recovery = DmaRecovery::new(
recovery_interface_base_addr,
caliptra_base_addr,
mci_base_addr,
dma,
);
dma_recovery.load_from_mcu_to_buffer(0, manifest_words)?;
report_boot_status(FwProcessorManifestLoadComplete.into());
Ok(*manifest)
}
/// Verify the image
///
/// # Arguments
///
/// * `env` - ROM Environment
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn verify_image(
venv: &mut FirmwareImageVerificationEnv,
manifest: &ImageManifest,
img_bundle_sz: u32,
) -> CaliptraResult<ImageVerificationInfo> {
let dma = if let caliptra_common::verifier::ImageSource::McuSram(dma) = &venv.image_source {
Some(*dma)
} else {
None
};
#[cfg(feature = "fake-rom")]
let venv = &mut FakeRomImageVerificationEnv {
sha256: venv.sha256,
sha2_512_384: venv.sha2_512_384,
sha2_512_384_acc: venv.sha2_512_384_acc,
soc_ifc: venv.soc_ifc,
data_vault: venv.data_vault,
ecc384: venv.ecc384,
mldsa87: venv.mldsa87,
image_source: match &venv.image_source {
caliptra_common::verifier::ImageSource::MboxMemory(img) => {
crate::flow::fake::ImageSource::Memory(img)
}
caliptra_common::verifier::ImageSource::McuSram(dma) => {
crate::flow::fake::ImageSource::McuSram(dma)
}
_ => panic!("Image source cannot be fips test"),
},
};
// Random delay for CFI glitch protection.
CfiCounter::delay();
CfiCounter::delay();
CfiCounter::delay();
CfiCounter::delay();
let recovery_interface_base_addr = venv.soc_ifc.recovery_interface_base_addr().into();
let mci_base_addr = venv.soc_ifc.mci_base_addr().into();
let caliptra_base_addr = venv.soc_ifc.caliptra_base_axi_addr().into();
let mut verifier = ImageVerifier::new(venv);
let info = verifier.verify(manifest, img_bundle_sz, ResetReason::ColdReset);
// If running in subsystem mode, set the recovery status.
if let Some(dma) = dma {
let dma_recovery = DmaRecovery::new(
recovery_interface_base_addr,
caliptra_base_addr,
mci_base_addr,
dma,
);
// Reset the RECOVERY_CTRL register Activate Recovery Image field by writing 0x1.
dma_recovery.reset_recovery_ctrl_activate_rec_img()?;
let (recovery_status, next_image_idx, device_status) = if info.is_err() {
(
DmaRecovery::RECOVERY_STATUS_IMAGE_AUTHENTICATION_ERROR,
0,
DmaRecovery::DEVICE_STATUS_FATAL_ERROR,
)
} else {
// we still have to do the SoC and MCU images
// we pre-emptively set the next image index to 1 so that the recovery interface
// will receive the right index so that no matter what order the recovery registers
// are read, we will send the right image next
(
DmaRecovery::RECOVERY_STATUS_AWAITING_RECOVERY_IMAGE,
1,
DmaRecovery::DEVICE_STATUS_READY_TO_ACCEPT_RECOVERY_IMAGE_VALUE,
)
};
cprintln!(
"[fwproc] Setting device recovery status to 0x{:x}, image index 0x{:x}, device status 0x{:x}",
recovery_status,
next_image_idx,
device_status
);
dma_recovery.set_recovery_status(recovery_status, next_image_idx)?;
dma_recovery.set_device_status(device_status)?;
}
let info = match info {
Ok(value) => value,
Err(e) => Err(e)?,
};
cprintln!(
"[fwproc] Img verified w/ Vendor ECC Key Idx {}, PQC Key Type: {}, PQC Key Idx {}, with SVN {} and effective fuse SVN {}",
info.vendor_ecc_pub_key_idx,
if FwVerificationPqcKeyType::from_u8(manifest.pqc_key_type) == Some(FwVerificationPqcKeyType::MLDSA) { "MLDSA" } else { "LMS" },
info.vendor_pqc_pub_key_idx,
info.fw_svn,
info.effective_fuse_svn,
);
report_boot_status(FwProcessorImageVerificationComplete.into());
Ok(info)
}
/// Update the fuse log
///
/// # Arguments
/// * `log_info` - Image Verification Log Info
///
/// # Returns
/// * CaliptraResult
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn update_fuse_log(
log: &mut FuseLogArray,
log_info: &ImageVerificationLogInfo,
) -> CaliptraResult<()> {
// Log VendorPubKeyIndex
log_fuse_data(
log,
FuseLogEntryId::VendorEccPubKeyIndex,
log_info.vendor_ecc_pub_key_idx.as_bytes(),
)?;
// Log VendorPubKeyRevocation
log_fuse_data(
log,
FuseLogEntryId::VendorEccPubKeyRevocation,
log_info
.fuse_vendor_ecc_pub_key_revocation
.bits()
.as_bytes(),
)?;
// Log cold-boot FW SVN
log_fuse_data(
log,
FuseLogEntryId::ColdBootFwSvn,
log_info.fw_log_info.manifest_svn.as_bytes(),
)?;
// Log ManifestReserved0
log_fuse_data(
log,
FuseLogEntryId::ManifestReserved0,
log_info.fw_log_info.reserved.as_bytes(),
)?;
// Log DeprecatedFuseFmcSvn (which is now the same as FuseFwSvn)
#[allow(deprecated)]
log_fuse_data(
log,
FuseLogEntryId::_DeprecatedFuseFmcSvn,
log_info.fw_log_info.fuse_svn.as_bytes(),
)?;
// Log ManifestFwSvn
log_fuse_data(
log,
FuseLogEntryId::ManifestFwSvn,
log_info.fw_log_info.manifest_svn.as_bytes(),
)?;
// Log ManifestReserved1
log_fuse_data(
log,
FuseLogEntryId::ManifestReserved1,
log_info.fw_log_info.reserved.as_bytes(),
)?;
// Log FuseFwSvn
log_fuse_data(
log,
FuseLogEntryId::FuseFwSvn,
log_info.fw_log_info.fuse_svn.as_bytes(),
)?;
// Log VendorPqcPubKeyIndex
log_fuse_data(
log,
FuseLogEntryId::VendorPqcPubKeyIndex,
log_info.vendor_pqc_pub_key_idx.as_bytes(),
)?;
// Log VendorPqcPubKeyRevocation
log_fuse_data(
log,
FuseLogEntryId::VendorPqcPubKeyRevocation,
log_info.fuse_vendor_pqc_pub_key_revocation.as_bytes(),
)?;
Ok(())
}
/// Load the image to ICCM
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `txn` - Mailbox Receive Transaction (Some in passive mode, None in subsystem mode)
/// * `soc_ifc` - SoC Interface
/// * `dma` - DMA engine
///
// Inlined to reduce ROM size
#[inline(always)]
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image(
manifest: &ImageManifest,
txn: Option<&mut MailboxRecvTxn>,
soc_ifc: &mut SocIfc,
dma: &mut Dma,
) -> CaliptraResult<()> {
if let Some(txn) = txn {
Self::load_image_from_mbox(manifest, txn)
} else {
Self::load_image_from_mcu(manifest, soc_ifc, dma)
}
}
/// Load the image from mailbox SRAM to ICCM
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `txn` - Mailbox Receive Transaction
///
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image_from_mbox(
manifest: &ImageManifest,
txn: &mut MailboxRecvTxn,
) -> CaliptraResult<()> {
cprintln!(
"[fwproc] Load FMC at address 0x{:08x} len {}",
manifest.fmc.load_addr,
manifest.fmc.size
);
let mbox_sram = txn.raw_mailbox_contents();
let fmc_dest = unsafe {
let addr = (manifest.fmc.load_addr) as *mut u8;
core::slice::from_raw_parts_mut(addr, manifest.fmc.size as usize)
};
let start = size_of::<ImageManifest>();
let end = start + fmc_dest.len();
if start > end || mbox_sram.len() < end {
Err(CaliptraError::FW_PROC_INVALID_IMAGE_SIZE)?;
}
fmc_dest.copy_from_slice(&mbox_sram[start..end]);
cprintln!(
"[fwproc] Load Runtime at address 0x{:08x} len {}",
manifest.runtime.load_addr,
manifest.runtime.size
);
let mbox_sram = txn.raw_mailbox_contents();
let runtime_dest = unsafe {
let addr = (manifest.runtime.load_addr) as *mut u8;
core::slice::from_raw_parts_mut(addr, manifest.runtime.size as usize)
};
let start = size_of::<ImageManifest>() + manifest.fmc.size as usize;
let end = start + runtime_dest.len();
if start > end || mbox_sram.len() < end {
Err(CaliptraError::FW_PROC_INVALID_IMAGE_SIZE)?;
}
runtime_dest.copy_from_slice(&mbox_sram[start..end]);
report_boot_status(FwProcessorLoadImageComplete.into());
Ok(())
}
/// Load the image from MCU SRAM to ICCM using DMA
///
/// # Arguments
///
/// * `manifest` - Manifest
/// * `soc_ifc` - SoC Interface
/// * `dma` - DMA engine
///
#[cfg_attr(not(feature = "no-cfi"), cfi_impl_fn)]
fn load_image_from_mcu(
manifest: &ImageManifest,
soc_ifc: &mut SocIfc,
dma: &mut Dma,
) -> CaliptraResult<()> {
// Get MCU SRAM address
let mci_base_addr: AxiAddr = soc_ifc.mci_base_addr().into();
let recovery_interface_base_addr: AxiAddr = soc_ifc.recovery_interface_base_addr().into();
let caliptra_base_addr: AxiAddr = soc_ifc.caliptra_base_axi_addr().into();
let dma_recovery = DmaRecovery::new(
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | true |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/ecdsa_verify.rs | rom/dev/src/flow/cold_reset/fw_processor/ecdsa_verify.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
ecdsa_verify.rs
Abstract:
File contains ECDSA384_SIGNATURE_VERIFY mailbox command.
--*/
use caliptra_common::mailbox_api::MailboxRespHeader;
use caliptra_drivers::{report_fw_error_non_fatal, CaliptraResult, Ecc384};
pub struct EcdsaVerifyCmd;
impl EcdsaVerifyCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
ecc384: &mut Ecc384,
_resp: &mut [u8],
) -> CaliptraResult<usize> {
let result = caliptra_common::verify::EcdsaVerifyCmd::execute(ecc384, cmd_bytes);
match result {
Ok(_) => {
// Zero value of response buffer is good
Ok(core::mem::size_of::<MailboxRespHeader>())
}
Err(e) => {
report_fw_error_non_fatal(e.into());
// Return 0 to indicate failure
Ok(0)
}
}
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
chipsalliance/caliptra-sw | https://github.com/chipsalliance/caliptra-sw/blob/d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c/rom/dev/src/flow/cold_reset/fw_processor/get_idev_csr.rs | rom/dev/src/flow/cold_reset/fw_processor/get_idev_csr.rs | /*++
Licensed under the Apache-2.0 license.
File Name:
get_idev_csr.rs
Abstract:
File contains GET_IDEV_ECC384_CSR and GET_IDEV_MLDSA87_CSR mailbox commands.
--*/
use caliptra_common::mailbox_api::{GetIdevCsrResp, MailboxReqHeader, ResponseVarSize};
use caliptra_drivers::{CaliptraError, CaliptraResult, PersistentData};
use zerocopy::FromBytes;
pub struct GetIdevEcc384CsrCmd;
impl GetIdevEcc384CsrCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
persistent_data: &mut PersistentData,
resp: &mut [u8],
) -> CaliptraResult<usize> {
MailboxReqHeader::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
// Use the response buffer directly as GetIdevCsrResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<GetIdevCsrResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let csr_resp = GetIdevCsrResp::mut_from_bytes(resp)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let csr_persistent_mem = &persistent_data.rom.idevid_csr_envelop.ecc_csr;
if csr_persistent_mem.is_unprovisioned() {
// CSR was never written to DCCM. This means the gen_idev_id_csr
// manufacturing flag was not set before booting into ROM.
return Err(CaliptraError::FW_PROC_MAILBOX_GET_IDEV_CSR_UNPROVISIONED_CSR);
}
let csr = csr_persistent_mem
.get()
.ok_or(CaliptraError::ROM_IDEVID_INVALID_CSR)?;
csr_resp.data_size = csr_persistent_mem.get_csr_len();
csr_resp.data[..csr_resp.data_size as usize].copy_from_slice(csr);
let resp_bytes = csr_resp.as_bytes_partial()?;
Ok(resp_bytes.len())
}
}
pub struct GetIdevMldsa87CsrCmd;
impl GetIdevMldsa87CsrCmd {
#[inline(always)]
pub(crate) fn execute(
cmd_bytes: &[u8],
persistent_data: &mut PersistentData,
resp: &mut [u8],
) -> CaliptraResult<usize> {
MailboxReqHeader::ref_from_bytes(cmd_bytes)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
// Use the response buffer directly as GetIdevCsrResp.
// The buffer is zeroized at the start of the loop
let resp_buffer_size = core::mem::size_of::<GetIdevCsrResp>();
let resp = resp
.get_mut(..resp_buffer_size)
.ok_or(CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let csr_resp = GetIdevCsrResp::mut_from_bytes(resp)
.map_err(|_| CaliptraError::FW_PROC_MAILBOX_INVALID_REQUEST_LENGTH)?;
let csr_persistent_mem = &persistent_data.rom.idevid_csr_envelop.mldsa_csr;
if csr_persistent_mem.is_unprovisioned() {
// CSR was never written to DCCM. This means the gen_idev_id_csr
// manufacturing flag was not set before booting into ROM.
return Err(CaliptraError::FW_PROC_MAILBOX_GET_IDEV_CSR_UNPROVISIONED_CSR);
}
let csr = csr_persistent_mem
.get()
.ok_or(CaliptraError::ROM_IDEVID_INVALID_CSR)?;
csr_resp.data_size = csr_persistent_mem.get_csr_len();
csr_resp.data[..csr_resp.data_size as usize].copy_from_slice(csr);
let resp_bytes = csr_resp.as_bytes_partial()?;
Ok(resp_bytes.len())
}
}
| rust | Apache-2.0 | d6e4f6fae9e4966ec1f5a52167a60c87fafecf1c | 2026-01-04T20:21:36.839730Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.