Data collected across development and deployment phases
The significance of a cryptographic fact depends on the phase at which, and the party by which, it was captured. Each CBOM therefore declares one lifecycle stage for the whole document. A reader can then interpret the statement that a product uses a given algorithm precisely: as a default the vendor ships, as a set an operator permits, or as a set someone saw on the wire.
The four lifecycle stages
The lifecycle model (version 1) defines four values: intended, implemented, configured and observed. The values form a flat list with no sub-values. Each value corresponds to one phase of the software lifecycle. Each phase has its own producer and its own data source.
Baseline rule interface-disclosure#P6 requires one stage per document. The producer declares the stage natively in CycloneDX, in metadata.lifecycles. The CycloneDX phase build means implemented, operations means configured, discovery means observed, and design means intended. An interface may still carry its own lifecycleStage (rule I8). Where it does, the value must agree with the document's stage. A party that holds facts from two stages writes two documents.
Information available at each phase
| Stage | Phase | A present-state value means | Establishes | Does not establish |
|---|---|---|---|---|
intended | Design | Not accepted by the baseline. See Where intention goes. | What the architecture is specified to use. | What was actually built. |
implemented | Build | The product's default as shipped. | What the shipped code or binary does by default, and, under the PQC migration profile, what it is capable of. The vendor writes this record. | What a deployment enables. A capability present in the code is not proof that it is used. |
configured | Deploy | The set of values the deployment permits. | What the deployed configuration permits. | Whether the configuration matches live sessions. Running systems can drift away from their configuration. |
observed | Runtime | The set of values seen in the observation window. | What was negotiated on the wire during that window. | Whether the observation will stay true. A later configuration change can make it out of date. Paths not exercised in the window are not covered. |
Rules I3 to I5 (key exchange, encryption and authentication) accept three literal values in place of an algorithm. A literal stands alone in the attribute. The literal none states that no algorithm does this job, and it is valid at any stage. The literal deployment-defined states that the product does not fix the value and that the operator chooses it, as with Keycloak's server certificate. The literal peer-defined states that the other endpoint decides the value or negotiates it with the product, as on a connection Keycloak opens to a database. These two literals are valid only at implemented. At configured and observed the operator knows the value, so the record must state it. The example cbom-keycloak-deployment-configured-fail-literal.cdx.json keeps peer-defined on the database connection and fails I3, I4 and I5 there. Decision 0012 gives the reason the literals exist: a rule that no legitimate subject can satisfy honestly is wrong, not strict.
Where intention goes
The baseline does not accept intended. The entry profile (Interface Enumeration) still accepts it. An intention is not a present state, and it belongs to one of three other places, depending on who holds it.
- A vendor's intention is a capability status. The PQC migration profile records it per cryptographic purpose (group rule G1). For example, the Keycloak product record states that ML-DSA token signing is
committed, with roadmap issue #43690. - An operator's intention is a requirement. The operator states it in a policy or in a tender, not in a CBOM.
- A design document is context. A record may point to a threat model or design document under reference rule R6 (design-intent). See Context Pointers.
The example cbom-keycloak-product-intended.cdx.json is a design record for Keycloak 27.0 with ML-DSA-65. It fails baseline rule I8 on every interface. It also fails I3 to I5 where it repeats the build-time literals. It conforms to the entry profile.
Relationship to SBOM Generation Context
The 2026 minimum elements guidance adds an element called SBOM Generation Context, defined as the relative software lifecycle phase and the data available when the author generated the SBOM. The reasoning given there matches the reasoning here: component data differs according to the phase at which it was captured, and a consumer assessing risk needs to know which phase that was.
The guidance gives "before build", "build", and "after build" as acceptable values and permits more specific identifiers. Our four stages map onto those values. The last value, "after build", is split into two stages, configured and observed. The split is needed because PQC migration depends on the difference between what a deployment permits and what it actually negotiates.
| Lifecycle stage used here | CycloneDX metadata.lifecycles phase | Corresponding generation context |
|---|---|---|
intended | design | before build |
implemented | build | build |
configured | operations | after build, as a more specific identifier |
observed | discovery | after build, as a more specific identifier |
A producer that follows the minimum elements guidance therefore already records what a profile needs, although possibly in less detail. Sometimes only the coarser value, such as "after build", is available. A consumer can then place the CBOM in the right part of the lifecycle. The consumer cannot tell whether a configured algorithm was actually used. The consumer should record this as a limitation and should not guess the finer stage. See References.
False positives and false negatives across the lifecycle
No single stage gives a complete or perfectly accurate picture. Each is prone to two kinds of error: a false positive, where cryptography is reported but is not actually in effect, and a false negative, where cryptography is in effect but is not reported. The balance between the two kinds of error changes as the product or service described moves from design to runtime.
| Stage | Typical false positive (reported, not in effect) | Typical false negative (in effect, not reported) |
|---|---|---|
intended | An algorithm specified in the design but never implemented. | Cryptography introduced during implementation, such as that inside libraries and dependencies, which the design did not foresee. |
implemented | Compiled-in capability, such as cipher suites or providers, that no deployment ever uses. | Cryptography loaded dynamically at runtime, provided by hardware (an HSM or TEE), or reached through dependencies the scanner does not cover. |
configured | An algorithm permitted by the configuration but never negotiated in practice. | Cryptography outside the inspected configuration, such as built-in defaults or out-of-band channels. |
observed | Cryptography seen only in a scan probe or a transient session, not representative of normal use. | Cryptography on paths not exercised during the observation window, such as failover, administrative, or rarely used interfaces. |
False positives are most common at the early stages. At those stages a design or a build reports what is possible rather than what runs. False positives are least common at runtime, because what is observed has actually happened. False negatives do not simply decrease from one stage to the next. Instead, the kind of cryptography that is missed changes. A design misses implementation detail. A static scan misses dynamic and hardware cryptography. A configuration misses whatever it does not govern. A runtime scan misses whatever was not exercised during the observation window.
For this reason, a consumer joins a product record to deployment records rather than using either alone. A product record describes what a product contains and comes from the implemented stage. It tends to over-report capability and to under-report runtime and hardware cryptography. A deployment record describes what a running deployment permits or uses, and comes from the configured or the observed stage. An observed record under-reports paths that nobody exercised during the observation window. Reading the records together reduces both kinds of error.
The readiness gap
The readiness gap is the difference between what a product is capable of and what is actually running. PQC-capable software and hardware do not, in themselves, guarantee that post-quantum cryptography is configured and active. Nor do they guarantee that it stays active after configuration changes. A product may be implemented with support for a given algorithm that is never configured and therefore never observed. In large migrations, interoperability and performance problems regularly appear as a system moves from one of these stages to the next.
Product record and deployment records
Each document describes one subject at one stage. Decision 0025 (baseline consolidation) fixes this arrangement. It generalises decision 0020, which said that a CBOM and vulnerability statements are joined, not merged.
- The vendor writes the product record. It describes the product at the
implementedstage: what the product does by default as shipped. Its subject identifier is a package URL (rule P3), and it declares the subject typeproduct(rule P5). - The operator writes deployment records, one at
configuredand one atobserved. A configured record states what the deployment permits. An observed record states what someone saw during an observation window. Their subject identifier is a tag URI (RFC 4151), such astag:example.org,2026:deployment/sso-prod, and they declare the subject typedeployment.
The two kinds of record are kept separate because they answer different questions and different parties write them. A deployment is usually built from several products, so its records draw on several product records. A cryptographic relationship is a place where cryptography is applied between two endpoints. These relationships exist in a deployment. They do not exist within any single product.
How the records are joined
The Deployment Disclosure profile defines the join. A deployment record cites the documents it builds on. Each citation is an entry in externalReferences of type bom. The entry carries the property pkic:profile:context with the value cited-document, a BOM-Link of the form urn:cdx:<serial>/<version>, and a SHA-256 hash of the cited document. A BOM-Link is the CycloneDX way to name one revision of another BOM. When the evaluator receives the cited document (with --with), it checks the serial number, the version and the hash. If the cited document has changed, the citing record fails deployment rule P1.
Each deployment interface also names the interface it realises. The property pkic:profile:correspondsTo holds a BOM-Link to that interface, of the form urn:cdx:<serial>/<version>#<bom-ref>. Where no product record exists, the property holds the literal no-product-document.
Only implementation facts cross a join. A deployment interface inherits its implementing library (rule I9, implementationPurl) from the interface it realises. It never inherits a present-state value, such as a key exchange group, because the product's default says nothing about what the deployment permits or negotiates. If the evaluator does not receive a cited document, it reports an inherited value as OPEN (unresolved). It does not fail the rule.
Why the distinction matters for PQC migration
PQC migration depends on the difference between what a product can do and what a deployment actually uses. A product record tells you whether a product can be made quantum-safe, and whether that requires a software update or a hardware change. Deployment records tell you whether a given deployment is quantum-safe today. One kind of record cannot replace the other:
- A product record on its own can overstate readiness. A product may support ML-KEM, but that says nothing about whether any deployment has enabled it.
- Deployment records on their own cannot show the upgrade path. Knowing that a deployment still negotiates a classical group does not tell you whether the underlying products can be reconfigured or must be replaced.
Migration planning needs both kinds. Product records identify which products can reach a quantum-safe target, and how. Deployment records identify which deployments have actually reached it, and which have not. Join the records one interface at a time. The join shows whether an interface needs a configuration change, a software update or a hardware refresh. It also shows whether a quantum-safe state is only planned or is actually running.
The readiness gap in the Keycloak example
The worked example joins three records of Keycloak 26.7.3. The vendor's product record describes the container image. An illustrative operator, Example Org, runs it as sso.example.org. TLS from clients ends at an nginx ingress with OpenSSL 3.5, and Keycloak runs with its plaintext HTTP listener enabled behind the ingress. Example Org's configured record describes that deployment. Its observed record describes what Example Org saw between 18 and 25 October 2026.
The example readiness-gap policy evaluated the three records on 2026-10-25. The result, examples/results/result-readiness-gap-sso-prod.json, names each record by its SHA-256 digest. It places each interface and purpose in one class. The table groups its 28 findings. Policy Evaluation defines the classes.
| Interface | Purpose | Class | What the joined records show |
|---|---|---|---|
| Ingress TLS (port 443) | key establishment | enabled-not-negotiated | The configured record permits X25519MLKEM768. The observed record shows that 29% of 1.2 million sessions still negotiated X25519 alone. The other endpoint or a fallback is the limit. |
| Ingress TLS (port 443) | entity authentication | unknown | The ingress has no product record, so nothing says what it can do. The certificate is ECDSA P-256. |
| Plaintext HTTP hop from the ingress to Keycloak (port 8080) | both | unprotected | No cryptography at the latest stage. Tokens cross this hop in the clear. |
| Management port 9000 (health and metrics) | both | unprotected | The port inherits the main server's scheme, which is plain HTTP in this deployment. |
| Token signing: OIDC, Admin API, brokered tokens | entity authentication | not-capable | ML-DSA signing is committed upstream (issue #43690). The JOSE AKP key type is still an Internet-Draft, so the standard blocks it. On the OIDC interface the observed tokens are ES256, and tokens for one client are still signed RS256. |
| Keycloak's own TLS: database, directory, cluster, identity provider | key establishment | not-capable | Post-quantum key exchange is planned. The Java runtime blocks it (JEP 527). |
| Keycloak's own TLS, SAML signing | entity authentication | not-capable | The product record states what blocks each one: a standard, or, for the cluster transport key, the product itself. |
| Realm key storage (database) | both | not-capable | Keycloak stores realm key material in the database in plaintext (issue #39933). The product record states that no change is planned. |
| Token encryption: OIDC, SAML, Admin API, brokered tokens | key establishment | not-applicable | Token encryption is off by default and off in this deployment. |
| Product HTTPS listener (port 8443), mail server connection | both | not-deployed | The product has these interfaces. The deployment does not configure them, because TLS ends at the ingress and no mail server is configured. |
The classes say who acts. Example Org acts on the plaintext hop and the management port. The supplier acts on token signing and on Keycloak's own TLS, and the product record names what blocks it. Nobody acts on the product HTTPS listener in this deployment. On the ingress, the limit for key establishment lies with the other endpoint or a fallback path. For authentication, nothing records what the ingress itself can do, so the class is unknown.
Failure modes across the lifecycle
A standardized algorithm in a validated module can still produce an insecure system. Ten distinct failure modes break cryptographic systems. Only one of them, algorithm strength, is fixed by replacing the algorithm. A migration plan scoped as "replace RSA and elliptic-curve key exchange with ML-KEM" therefore carries the other failure modes forward unchanged.
Each failure mode starts at a particular lifecycle stage. The evidence that reveals it is produced at a particular stage too, and often by a different party. The table sets out both, and states how much a CBOM in CycloneDX 2.0 can show.
| Failure mode | What fails | Starts at | Evidence that reveals it | Detectable from a CBOM |
|---|---|---|---|---|
| 1. Algorithm strength | The algorithm or parameter set is weaker than the threat requires. | intended | Any CBOM: algorithm family, parameter set, curve. | Yes |
| 2. Temporal strength | An algorithm adequate today becomes inadequate before the protection lifetime of the data or signature ends. | intended | The CBOM gives the algorithm. How long the data must stay secret, or a signature must stay verifiable, comes from data governance outside the CBOM. A deployment record points to it as the data-register context. See Context Pointers and Inventory. | Partly: the algorithm, not the lifetime |
| 3. Implementation | The algorithm is sound. The code computing it is wrong or leaks. | implemented | Advisories and VEX statements joined to the implementing library (rule I9), through the pointers that reference rules R2 and R3 require. See Vulnerabilities. | Only known-vulnerable versions |
| 4. Supply chain and version currency | The right library is deployed at the wrong version or specification revision. | implemented | Product CBOM and SBOM: component, version and package URL. | Mostly |
| 5. Usage | A strong, correctly implemented algorithm is used for a purpose it does not serve. | intended or implemented | A CBOM whose producer linked key material and code locations to the algorithm. Without those links the CBOM records only the algorithm name. | Partly, depending on the producing tool |
| 6. Integration | The cryptographic call succeeds, and the application ignores or misuses its result. | implemented | A code-analysis finding. The CBOM can point to it as code-analysis context, which no profile requires yet. | No |
| 7. Configuration | The deployed settings differ from the ones the design assumed. | configured | An observed record of what was negotiated, joined to the configured record. | Yes, by joining a configured and an observed record |
| 8. Key management and lifecycle | Algorithm, code and purpose are sound. The key is generated, stored, scoped, rotated or retired badly. | configured | Key and certificate metadata in the CBOM: type, state, dates, rotation and renewal, where the key is secured, fingerprint. | Mostly |
| 9. Entropy and environment | Correct code receives poor randomness from the platform. | observed (the running platform) | A platform assessment, which a CBOM can point to as platform-assessment context. A CBOM reveals the outcome only after keys exist, as duplicate fingerprints across a fleet. | No |
| 10. Composition and negotiation | Each component is safe, and the combination is not, especially under fallback. | observed (the running service) | Protocol testing of the running service. A CBOM can point to the report as protocol-testing context (a CycloneDX 2.0 test-report reference). | No |
Every failure mode has a long record of real breaks in the algorithms being replaced. ROCA (2017) made RSA keys from one key-generation library factorable although the algorithm and key size were sound. Firmware shipped with the same private keys in thousands of device models. DROWN (2016) decrypted modern TLS sessions through a server that accepted SSLv2 with the same RSA key. ML-KEM is exposed to the same failure modes. KyberSlash (2023–24) leaked keys through timing in the reference code. A hybrid group compiled into a product is never negotiated if the load balancer that terminates TLS does not offer it. An application that retries with a classical-only configuration after a failed handshake reopens the downgrade that TLS 1.3 otherwise prevents.
Product problems and deployment problems
Failure modes 3 to 6 start at the implemented stage. They show in a product record, read together with the product's SBOM, its advisories and code-analysis findings. Failure modes 7 to 10 start in deployment. Only configured and observed records, or tests of the running service, can show them. A product record cannot. This is the distinction between a product record and deployment records, applied to failure rather than to capability.
The configuration failure is the readiness gap seen from the other side. A library that supports ML-KEM proves nothing until the negotiated group is observed. The evidence for progress against harvest-now-decrypt-later is the handshake, not the version number.
What stays outside the CBOM
Seven of the ten failure modes need attributes that CycloneDX does not define, or evidence that a CBOM cannot carry. Three kinds of evidence belong beside the CBOM rather than in it, for the same reasons that vulnerability status and derived judgements do. The CBOM can point to each of them as context. The pointer names where the evidence is. It does not carry the evidence, and conformance never checks its content:
- Implementation defects are communicated by advisories and VEX statements joined to the implementing library. A defect without an advisory, such as a timing leak introduced by a compiler, does not appear in any of these documents.
- Integration failures are properties of the calling code. They are code-analysis findings, which the CBOM references rather than models.
- Entropy failures and fallback behaviour need a platform assessment and protocol testing of the running service.
A profile can still make the right failure modes visible. It does so by requiring the lifecycle stage at which a failure mode shows. A profile that requires observed data for each external interface exposes configuration failures. A profile that requires the implementing library as a package URL lets implementation defects be joined to advisories.
Multiple producers of a single interface's data
In the Keycloak example, three records describe the same interfaces at three stages, and two parties write them. Each record is a separate document.
- The product record (
cbom-keycloak-product.cdx.json,implemented) is the vendor's build record of the container image. It declares 13 cryptographic interfaces. On the HTTPS listener, the key exchange is X25519, the first group in the defaults of the JDK 21 in the image. The server certificate isdeployment-defined, and the interface points to the guide where the operator sets it (rule R5). On the database connection, the group and the server certificate arepeer-defined. - The configured record (
cbom-keycloak-deployment-configured.cdx.json,configured) is Example Org's record of its deployment, read from its configuration repository. TLS ends at the ingress, so the product's HTTPS listener does not appear. The ingress interface statescorrespondsTo = no-product-documentand states its own library, OpenSSL. The database connection states the groups the deployment permits, and corresponds to the product's database interface. - The observed record (
cbom-keycloak-deployment-observed.cdx.json,observed) is what Example Org saw between 18 and 25 October 2026. Each interface names its observation methods, such as a passive sensor or an active probe, and corresponds to an interface of the configured record. Two findings appear only here: 29% of ingress sessions still negotiate X25519 alone, and tokens for one client are still signed RS256.
The implementing library follows two joins. The observed database interface corresponds to the configured one, which corresponds to the product's. The evaluator, given both cited documents, resolves the library to the JDK 21 package named in the product record. For the ingress, the library comes from the configured record, because no product record exists.
Each profile states which stages and subject types it accepts. The baseline (the Interface Disclosure Baseline) accepts implemented, configured and observed, for products and deployments. The Deployment Disclosure profile accepts configured and observed deployment records. The PQC migration and procurement profiles accept only the implemented product record.
Stakeholders at each stage
Each stage has a different producer. In most cases, the party that produces the data is not the party that needs it. For that reason, the lifecycle stage has to be recorded rather than assumed. A consumer who receives a CBOM usually did not generate it. The consumer cannot tell from the content alone which phase the CBOM describes.
The table sets out who produces a CBOM at each stage, who typically consumes it, and which use cases the data at that stage can support. Some use cases appear against more than one stage, because they draw on data from each of those stages. This is common. Several use cases depend on comparing one stage with another rather than reading a single stage.
| Stage | Produced by | Consumed by | Use cases it supports |
|---|---|---|---|
intendeddesign |
Architects and security architects, from design documents and threat models. The baseline does not accept a record at this stage; a record points to the design document under R6 instead. | Architecture review boards; procurement teams writing requirements; the working group or sector body defining a profile. |
Crypto-agility assessment Procurement, for stating the requirement rather than checking it |
implementedbuild |
Development and build teams, from source and dependency analysis in the pipeline. | The vendor's own product security function; downstream integrators; operator procurement; security operations holding a component inventory. |
Procurement and tender conformance CI quality gate Vulnerability management Supply-chain transparency Crypto-agility assessment |
configureddeploy |
Integrators, platform and infrastructure teams, from deployment configuration and policy bundles. | Deployment gates; internal risk and assurance; migration programme leads. |
PQC migration readiness CI quality gate, at the admission step Compliance reporting |
observedruntime |
Operations and monitoring teams, from scanning and telemetry against the running service. | Assurance and audit; incident responders; regulators receiving a reported position; customers asking what a service actually uses. |
PQC migration readiness, for actual rather than declared state Incident response Compliance reporting Due diligence |
Consumers who never produce
Several stakeholders only consume CBOMs and never produce them. Their needs shape what a profile has to require. Regulators and auditors read a reported position that they had no part in generating. For that reason, provenance and lifecycle stage matter more to them than to anyone else. Customers and partners who send a supply-chain request are in the same position. They are usually the reason a CBOM has to be scoped and redacted before release, as described in the Inventory section. Organizations performing due diligence before an acquisition read CBOMs across an entire estate that they do not operate. For them, missing data is as significant as the data that is present.
Where the hand-offs fail
The stages are separated by a change of organization as often as by a change of time. Data is lost or becomes less reliable when it passes across these organizational boundaries.
- Between
implementedandconfiguredthe producer changes organization, from vendor to operator. A vendor cannot state what a deployment will enable, and an operator cannot see inside the binary. Neither party can produce a complete picture alone. This is the reason to join a product record to deployment records rather than choose between them. ThecorrespondsToproperty and the cited documents carry the join across the organizational boundary. - Between
configuredandobservedthe producer usually stays within one organization but changes team. Drift appears at this hand-off: the running system stops matching its configuration. Drift happens because configuration is authored once and running systems change afterwards. - Between
intendedandimplementedthe data is frequently lost entirely. Design intent is rarely carried into a machine-readable form, so a consumer cannot tell whether cryptography present in a build was deliberate or incidental. Reference rule R6 lets a record point to the design document, but it is a MAY, and the Keycloak product record carries no such pointer.
A profile can require the lifecycle stage to be declared. This makes these gaps visible. A profile cannot close the gaps. Closing them would require some party to produce data that it does not produce today. Whether that happens depends on adoption by those parties, not on what the specification says.
Progress tracking over time
Successive records form an audit trail. The Versioning section describes content revision as one of the things that carry their own version. Each new deployment record cites the records it builds on by BOM-Link and hash, so every record in the series is bound to the exact revisions before it. Suppose an operator enables post-quantum key exchange, and a later observed record shows that every session negotiates it. Each policy result names the records it read by digest. The series of records and results then gives internal governance and regulators a verifiable record of the migration.