Back to DashboardStrategyPhase 2 · CBOMintermediate60 min

Cryptography Bill of Materials (CBOM)

Choose a format, discover all your cryptography — including the crypto nobody tracks — and make the inventory machine-verifiable.

Why this matters: You can't migrate crypto you can't see; a Cryptography Bill of Materials is the inventory every later phase depends on.

Start here: Tick the discovery tools you already run in the Source Coverage Mapper: the assets found in the sample estate, the per-layer gaps, the best next scanner and the hidden ghost assets update live.

For your role

Executive / Business Leader
The Source Coverage Mapper shows which discovery tools you already run and where the blind spots are: the inventory every later migration phase depends on, and the first thing an auditor asks for.
GRC / Risk & Compliance
Pick CycloneDX or SPDX for the CBOM, evaluate the inventory against a quantum-safe policy, and collapse four artifacts into one logical key by SPKI fingerprint: the machine-verifiable inventory the audit checklist's 'CBOM generated' item refers to.
Developer / Engineer
The Source Coverage Mapper reuses the scanners and build tooling you already run; the format step compares CycloneDX and SPDX for cryptographic assets, and the last step deduplicates keys by SPKI fingerprint.
Security Architect
Choose the BOM format, then evaluate the resulting inventory against a quantum-safe policy: the module shows what a CBOM has to carry for a migration decision to be made from it.
IT Ops / DevOps
Map your existing discovery sources first, then evaluate the inventory against policy: the gaps are the systems nobody's scanner covers, which is where key rotations fail.
Practice in the Simulation

Why a CBOM, and where Phase 2 sits

● standardA Cryptography Bill of Materials (CBOM) is a machine-readable inventory of every cryptographic asset — algorithms, keys, certificates, protocols and their configurations — and how they relate to software components. It extends the SBOM: the SBOM lists your software, the CBOM lists the cryptography inside it.

In the migration lifecycle it is Phase 2: discovery (Phase 1) feeds the CBOM, and risk scoring (Phase 3) consumes it. A bare list of algorithms isn't enough — the value is a CBOM you can query and rank.

◆ practitionerStart with a Minimum Viable CBOM: capture the fields you need to prioritise (algorithm, where it's used, what it protects, owner), not a perfect catalogue. Regulators are converging on the same expectation: the EU's NIS Cooperation Group roadmap (v1.1, 11 Jun 2025) sets an end-2026 milestone for Member States whose first steps include mature cryptographic asset management, saying they “should promote and support that useful cryptographic inventories are being created and maintained” and naming CBOM as a recommended format. It is guidance to Member States rather than a direct obligation on you — but it is what national rules will be built from. In the US, Executive Order 14412 (22 Jun 2026) and OMB M-26-15 (24 Jun 2026) set the parallel federal civilian track: CISA must publish guidance on minimum CBOM elements by 19 March 2027 (EO +270 days), feeding agency and covered-contractor inventories ahead of the 31 December 2030 key-establishment and 31 December 2031 digital-signature deadlines.

Formats & governance: CycloneDX vs SPDX

● standardTwo widely used BOM specifications have different stewards and CBOM coverage: CycloneDX (OWASP; ECMA-424, 2nd edition, current spec v1.7) and SPDX (Linux Foundation; ISO/IEC 5962 for v2.3; released v3.0.1).

For a native, interoperable CBOM today, CycloneDX is the more complete released specification: version 1.7 defines cryptographic assets and a Cryptography Registry for consistent algorithm identifiers. Released SPDX 3.0.1 has no comparable dedicated cryptographic-asset model. SPDX 3.1 work is still a release candidate, and the SPDX Cryptographic Algorithms List is a separate community list rather than a released CBOM schema. Treat SPDX cryptographic inventory support as evolving; check the target specification and tool support before choosing it.

● standardThe PKI Consortium CBOM-Profiles Working Group (launched 8 Jun 2026) is building a neutral methodology so a CBOM profile maps onto both formats — the format-neutral future.

Find all the crypto: layered discovery

◆ practitioner“Ghost” crypto is every cryptographic use that isn't in any inventory — shadow-IT services, forgotten-but-live certs, hardcoded algorithms, embedded/OT crypto, default library crypto. A CBOM built only from known systems is falsely reassuring. You can't migrate what you can't find.

◆ practitionerReuse before you deploy. A new agent rollout is usually the real blocker. Pull from tools you already run as discovery sources — Qualys / Tenable / Rapid7 and on-host agents (which surface TLS endpoints, ciphers and certs), Venafi / Keyfactor / DigiCert for certificates — and scan net-new only where you are blind.

● standardNo single method finds it all — layer five: source code (sonar-cryptography / CBOMkit, IBM Quantum Safe Explorer), binary / container (CBOMkit-theia), network / traffic (passive handshake capture + active scanning), infrastructure / runtime (HSM/KMS, CLM, CT logs), and cloud (KMS/cert APIs + CSPM — no host to scan, provider-managed crypto, shared responsibility). Coverage = the union.

Estate mapping — what to record per instance

◆ practitionerFramework v2.1 Activity 1.3 defines 13 mandatory fields per cryptographic instance. Recording them consistently is what turns a raw discovery export into a queryable, risk-rankable backlog that Phase 3 can score and Phase 4 can sequence.

System / Asset ID

Linked to your CMDB — the anchor that ties the crypto instance to an owned, managed asset.

Cryptographic Function

Key exchange, signing, encryption at rest, MAC, hashing — what the crypto is doing.

Algorithm

Fully qualified: RSA-2048, ECDHE-P256, AES-256-GCM. Avoid shorthand (e.g. "RSA") — the key size determines vulnerability.

Key Size (bits)

Critical for quantum-vulnerability classification; a 1024-bit RSA key is more urgent than a 4096-bit one.

Protocol

TLS 1.2 / 1.3, SSH 2.0, IPsec IKEv2, S/MIME — the transport context.

Library / Implementation

OpenSSL 3.0.12, BoringSSL, Java 17 JCA — the version determines upgrade path and CVE exposure.

Certificate Details

Issuer, validity period, chain depth. Long-lived roots (20-year) are a TNFL risk; expiry gaps are a classical risk.

Key Lifetime

Ephemeral (per-session), short (1 year), long-lived (20-year root). Drives both HNDL and TNFL risk scoring.

Data Sensitivity

Confidential / Restricted / Public — feeds the HNDL urgency calculation in Phase 3.

Quantum Vulnerability

Shor-vulnerable (RSA, ECC, DH), Grover-weakened (symmetric, hashes), or neither. Set by algorithm + key size.

Owner

The team or person accountable for migrating this instance. No owner = no migration action.

Vendor Dependency

Whether migration requires a vendor to ship a PQC-capable version. Flags Phase 7 vendor-orchestration work.

Control Posture

Full (control both endpoints), Partial (one endpoint only), or None (third-party managed). Determines migration feasibility.

Minimum Viable CBOM shortcut: if full capture is too slow, start with Algorithm + Key Size + Owner + Control Posture. Those four fields alone let you produce a prioritized remediation queue and unblock Phase 3 scoring for your highest-risk systems.

Key identity, provenance & where it's managed

◆ practitionerDiscovery finds artifacts; risk needs context. Attach to each key what it protects (+ confidentiality horizon = the HNDL input), its purpose (Track A vs B), location, owner, vendor-dependency, and active-vs-dormant. That enrichment turns an inventory into a risk-rankable backlog.

● standardTwo kinds of identifier. Assigned ids are local and don't correlate (PKCS#11 CKA_ID, KMIP Unique Identifier, KMS key-id, JWK kid). Content-derived ids can correlate, but only when the scheme, hash and input encoding match. An X.509 SKI is commonly a SHA-1 hash of the subjectPublicKey bit string (or a 60-bit truncation of it), but RFC 5280 also allows other methods. A JWK Thumbprint (RFC 7638) hashes a canonical JSON form of the key's required members with a hash function the user chooses, so it is not an SPKI hash. A KMIP Digest is computed over the key material in a stated key format type, not over the DER SubjectPublicKeyInfo. A KCV (PKCS#11 CKA_CHECK_VALUE) is a 3-byte check value for a symmetric key, and PKCS#11 states that two different keys can have the same value: with only 24 bits, about 4,800 random keys already give a 50% chance of at least one collision.

◆ practitionerSimilar names can carry different amounts of information. CKM_ECDSA_SHA256 in PKCS#11 and the certificate signature OID 1.2.840.10045.4.3.2 (ecdsa-with-SHA256) identify ECDSA with SHA-256; neither identifier alone specifies the curve. Read the signing key's curve parameters separately: for example, PKCS#11 CKA_EC_PARAMS or the signing public key's named-curve parameters in SubjectPublicKeyInfo. For a certificate signature, this is the issuer's signing key, not necessarily the subject's key.

In contrast, JOSE ES256 specifies P-256 with SHA-256, and in TLS 1.3 0x0403 names ecdsa_secp256r1_sha256. Record the identifier's namespace and protocol version, algorithm, curve, hash and signature encoding before matching records. If the curve is missing, keep it unknown rather than assuming P-256. Matching algorithm parameters does not establish that two records refer to the same key.

Sources: PKCS#11 mechanisms and key attributes, RFC 5758 signature OIDs, RFC 5480 public-key parameters, RFC 7518 ES256, and RFC 8446 TLS signature schemes.

◆ practitionerTo correlate “same key across HSM / cert / code / wire”, recompute one agreed fingerprint (for example SHA-256 of the DER SubjectPublicKeyInfo) from normalized, comparable public-key material, and treat a match as strong evidence rather than proof of a unique key until the key material or a signature check confirms it. The sample grouping in this module shows the idea; a production tool also needs, for each record, the identifier scheme, the hash algorithm, the exact input encoding and the source, plus the normalization step that turns each source's form into the comparable one.

● standardAttestation is evidence about a key, and what it proves depends on what you verify: that the chain validates to a trust anchor you accept and nothing in it is revoked; that the evidence is bound to the specific public key in front of you; what it says about origin (generated on the device or imported) and the enforcement level (for Android key attestation, the attestationSecurityLevel must be TrustedEnvironment or StrongBox, and only the first key-description extension in the chain can be trusted); and, where the format has one, that a fresh challenge ties it to your request. Hardware residency is not the same as non-exportability: export and backup behavior is configuration (in PKCS#11, CKA_EXTRACTABLE, CKA_NEVER_EXTRACTABLE and CKA_LOCAL for keys generated on the token), so read what the attestation claims about export and backup instead of assuming it. For PQC, attesting generation in a FIPS 140-3-validated module is a claim about the module, so check that the certificate covers the exact module and mode. For any sample you are given, ask which of origin, hardware residency, non-exportability, key binding and freshness it actually proves, and which it leaves unproven. And record where the key is managed — software (exportable, sprawl-prone), HSM (hardware-resident; whether it is non-exportable depends on its configuration), or cloud KMS (API-mediated, envelope encryption) — it drives risk and migration feasibility.

Codifying & normalizing crypto

◆ practitionerOne mechanism has many names. ECDSA with SHA-256 is CKM_ECDSA_SHA256 to an HSM and OID 1.2.840.10045.4.3.2 in a certificate, with the curve taken from the key's parameters; ES256 to a JWT and 0x0403 to TLS 1.3 also name P-256 — and the curve alone is P-256 = secp256r1 = prime256v1. Six codification layers (spec, OID, protocol code point, key-mgmt enum, library string, CBOM) with no shared key.

● standardPQC makes it worse. Each parameter set is its own algorithm: ML-DSA chose one OID per parameter set, parameters absent (id-ml-dsa-44/65/87, RFC 9881), so OIDs proliferate. Hybrid KEMs (X25519MLKEM768) and composite signatures each get their own identifier — combination × nomenclature.

● standardThe answer is to map every source onto a canonical model (the CycloneDX Cryptography Registry) while never over-collapsing security-relevant parameters (mode, padding, curve, hash). The PKIC CBOM-Profiles WG is the neutral venue maintaining this as registries keep moving.

For the full family/curve reference and a hands-on normalizer, see the dedicated CycloneDX Cryptography Registry module.

Make it machine-verifiable & protect it

● standardMachine-verifiable in practice = policy-as-code. CBOMkit runs an OPA/Rego check classifying each asset quantum-safe / quantum-vulnerable / na / unknown, queryable over a REST API. Normalized names (above) are what make the rules match reliably.

◆ practitionerSecure the CBOM. The CBOM plus the risk backlog is a map of your weakest cryptography — an attacker's shopping list. Protect it with access control and integrity, the way you would any sensitive asset inventory.

In the Industry Landscape

Check your understanding

17 questions on Cryptography Bill of Materials (CBOM), each with its answer and the reason.

Take the quiz

Next step

Produce the artifact: Crypto BOM (CBOM) Builder

This module belongs to phase 2 (CBOM); Crypto BOM (CBOM) Builder produces a deliverable of that phase in the Command Center.

Production Tool Capabilities & Verification Checklist

Capabilities to require in your production tools:

  • Automated CycloneDX v1.6+ Cryptographic Bill of Materials (CBOM) generation (`cryptoProperties.assetType`: `algorithm`, `certificate`, `related-crypto-material`, `protocol`) integrated into CI/CD and network discovery.
  • Correlation of static source/binary CBOM findings with runtime TLS/SSH/PKI telemetry to eliminate blind spots.
  • OID and parameter-set tagging (`ML-KEM-768`, `ML-DSA-65`, `RSA-2048`) driving automated remediation tickets.

How to evaluate in your environment

Generate a CycloneDX 1.6 CBOM JSON from a target repository/container and validate it against the official CycloneDX JSON schema and live runtime cipher usage.

Production evidence to collect

Schema-validated CycloneDX 1.6 CBOM JSON artifact, CI pipeline scan log, and runtime-vs-static reconciliation report.

Completing this Hub module and its browser-based sample exercises teaches the technical and governance decision criteria for your role; it does not test, validate, or certify your deployed production systems.

Record evidence for your environment

Identify the tested build and configuration. Use reference IDs for observations. For a proposed exclusion, record the system boundary or rule and why it excludes this build.

Automated CycloneDX v1.6+ Cryptographic Bill of Materials (CBOM) generation (`cryptoProperties.assetType`: `algorithm`, `certificate`, `related-crypto-material`, `protocol`) integrated into CI/CD and network discovery.
Correlation of static source/binary CBOM findings with runtime TLS/SSH/PKI telemetry to eliminate blind spots.
OID and parameter-set tagging (`ML-KEM-768`, `ML-DSA-65`, `RSA-2048`) driving automated remediation tickets.

Evidence missing. 0 of 3 requirements have a reference or scope rationale.

Learning module content can be inaccurate. Please double-check its information. Report inaccuracies in PQC Today GitHub Discussions.