The profile: Interface Disclosure Baseline
The Interface Disclosure Baseline, v0.9, is product-independent. Its rules are structural: they say which categories of cryptographic interface must exist, what each one must disclose, and which context the document must point to. Written that way, they apply to any product and to any deployment of it. No rule names a specific product or a specific interface instance. The worked example is Keycloak 26.7.3, and the full write-up is profile-interface-disclosure.md.
Two directions of use
The profile contains one attribute table. Two different parties use that same table for two different purposes.
Subjects and stages
One baseline serves two subject types. The vendor writes the product record: what the product does as built, at the implemented stage. The operator writes deployment records: what one deployment permits (configured) and what it was seen to do (observed). The rules describe an interface the same way in both. Only the subject identifier and some reference rules differ, and the profile keys them by subject type.
| Subject type | Written by | Stages | Identifier (P3) |
|---|---|---|---|
product | vendor | implemented | a Package URL, such as pkg:oci/keycloak?repository_url=quay.io/keycloak/keycloak&tag=26.7.3 |
deployment | operator | configured, observed | a tag URI (RFC 4151), such as tag:example.org,2026:deployment/sso-prod |
A tag URI is an identifier that anyone who controls a domain name can mint, with no registration. That suits an operator naming its own deployments, which have no Package URL.
One document has one subject and one stage. The document carries its stage natively in CycloneDX metadata.lifecycles: build means implemented, operations means configured, and discovery means observed. A per-interface lifecycleStage, where present, must agree. A vendor's build record and an operator's scan come from different parties at different times. Mixing them in one document would count one boundary twice, and would let a producer fill a gap at one stage with a value from another. The readiness gap comes from joining a record at one stage to a record at another, not from merging them.
The meaning of a present-state value such as keyExchange depends on the stage. At implemented it is the product's default as shipped. At configured it is the set the deployment permits. At observed it is the set seen during the observation window.
The baseline does not accept intended. A design intention says nothing about deployed interfaces. A vendor's intention is a capability status under the PQC migration profile: Keycloak's ML-DSA token signing, for example, is committed (issue #43690). An operator's intention is a requirement, held in a policy or a tender. A design document is context, and the document points to it under R6. The entry profile, Interface Enumeration, still accepts intended.
Four kinds of rule
management interface, or to state why the product has none. cbom-keycloak-product-fail-P2.cdx.json leaves out both management interfaces and fails P2, even though every interface it does declare is fully described.Product-level rules (constraints on the document and its set of interfaces)
| # | Requirement | Level | Constraint |
|---|---|---|---|
| P1 | Declare at least one cryptographic interface | MUST | minInterfaces: 1 |
| P2 | Declare at least one management interface, or state why there is none | MUST | minInterfacesOfType: {management, 1}, orDeclaredAbsent, orCitedDeclares |
| P3 | Identify the subject the document describes: a Package URL for a product, a tag URI for a deployment | MUST | subjectIdentified: {product: pkg:, deployment: tag:} |
| P4 | State how complete the declared interface set is: all, all-external or partial | MUST | productAttribute: coverage |
| P5 | Declare the subject type, product or deployment | MUST | subjectDeclared |
| P6 | Declare one lifecycle stage, and report that stage on every interface | MUST | singleStage |
P1 and P2 catch omissions. Per-attribute rules cannot catch them, because those rules only check the interfaces a document actually declares. For example, a document may describe its service interface accurately and say nothing about how the product is administered. That document passes every interface rule, but it fails P2. A producer satisfies P2 in one of two ways: by declaring a management interface, or by stating that the subject has none. Some subjects, such as a library or a hardware token with no configuration surface, have no management interface. Stating that absence hides nothing. What P2 rules out is saying nothing at all about management. P2 therefore applies the disclosure model (the rules for how a producer accounts for information it does not supply) to the structure of the document rather than to a single attribute.
Product rules require disclosure. They never require a product to be built in a particular way. P2 does not say that a product must have a management interface. It says that the document must state whether the product has one, and declare it if it does. A rule that names a kind of interface follows the same pattern: the document declares an interface of that kind, or states that there is none. A false statement of absence is a misstatement by the producer, which the consumer can take up under its contract. Whether a product should have a particular interface is a purchasing requirement, and it belongs in the contract, not in the profile.
Two more routes through P2 apply only to an observed record. If the observer could not reach the management interface, P2 passes when a configured record that the document cites declares one. The gap stays visible through the join, as an interface with no observed counterpart. An observer with no configured record to cite, such as an outside assessor, states the reason not-reached. The validator accepts that reason only with coverage partial. The report says which route the document took.
P3 and P4 make the document usable as a record of a specific subject, not only as a description. Without P3, a CBOM does not have to say which product or deployment it describes. The CBOM then cannot be matched to anything else or compared with the same subject's CBOM from last quarter. Without P4, a reader cannot interpret a missing interface. The interface might not exist, or the producer might have chosen not to list it, and those two situations are entirely different. The Conformance section identifies these two gaps as the non-assertions (things a CBOM leaves unstated) most likely to cause difficulty in procurement. P3 and P4 are the rules that address them.
P5 and P6 make the subject and the stage explicit. A consumer cannot tell from the content alone whether a record describes a product as built or one deployment of it. P5 makes the document say so, and P6 keeps one document to one stage.
Per-interface rules (applied to every interface)
Attribute names follow the conventions in Method. A bare name describes the interface's present state, so keyExchange is the key exchange the interface uses now. A profile that needs to record what an interface is declared to support adds the Supported suffix to the name. The PQC Migration profile does this.
| # | Attribute | Level | Notes |
|---|---|---|---|
| I1 | protocol | MUST | TLS, SSH, IPsec, OIDC, SAML, and similar. Not required of a storage interface |
| I2 | protocolVersion | MUST | Not required of a storage interface |
| I3 | keyExchange | MUST | registry algorithm identifier, or a literal. Not required of a storage interface |
| I4 | encryption | MUST | bulk or AEAD algorithm, or a literal |
| I5 | authentication | MUST | the signature that proves the sender: certificate signature (TLS), host key (SSH) or token signature (OIDC, SAML), or a literal. Not required of a storage interface |
| I6 | endpointRoles | MUST | at least two endpoints. Not required of a storage interface |
| I7 | interfaceType | MUST | from the controlled vocabulary |
| I8 | lifecycleStage | MUST | implemented, configured or observed. The interface's own value, or the document's stage where it has none. See Lifecycle Data |
| I9 | implementationPurl | MUST | Package URL of the implementing library. Withholdable, which means the producer may decline to publish the value. A withheld marker satisfies the rule, but silent omission does not. I9 is the only rule in this table where the disclosure state decides whether the rule passes. |
| I10 | keyWrapping | MUST on a storage interface | the algorithm that protects the data keys at rest, or none. It stands in for I3 on storage |
| I11 | defaultState | SHOULD, at implemented | enabled or disabled: whether the interface is active in the product's default configuration |
A storage interface is data at rest. It has no protocol, peer or handshake, so the channel rules (I1, I2, I3, I5 and I6) do not apply to it, and I10 takes the place of I3. A network path to remote storage is declared as its own service or interconnect interface and owes the channel rules there. See decision 0022.
I11 exists because some interfaces are present in a product and off by default. Keycloak's plaintext HTTP listener is one. Declared without defaultState, it reads as an active plaintext interface. Left out, it hides the interface that becomes the plaintext hop behind a TLS-terminating proxy. In a deployment record, every declared interface is active, so I11 applies only at implemented.
Literal values
I3, I4 and I5 accept three literal values in place of an algorithm. A literal is a value, not a disclosure marker, and it stands alone.
| Literal | Meaning | Accepted at | Keycloak example |
|---|---|---|---|
none | The interface applies no algorithm for this job. | any stage | Token encryption is off by default, so the OIDC interface declares keyExchange none. |
deployment-defined | The product does not fix the value. The operator chooses it. | implemented only | The operator supplies the server certificate, so the HTTPS listener declares authentication deployment-defined. |
peer-defined | The other endpoint decides the value, or the product negotiates it with that endpoint. | implemented only | On the connection Keycloak opens to its database, the database decides the group and the certificate. |
At configured or observed, the producer holds the answer and must give it. cbom-keycloak-deployment-configured-fail-literal.cdx.json keeps peer-defined at configured and fails I3, I4 and I5 on the database connection. Without the two stage-restricted literals, a truthful build record of Keycloak failed I5 on 7 of its 13 interfaces. Decision 0012 states the principle: a rule that no legitimate subject can satisfy honestly is wrong, not strict.
none differs from the disclosure markers. none is a claim about the product. unknown reports that the producer does not know, and withheld reports that the producer declines to say.
Derived evaluations such as post-quantum posture are deliberately not profile attributes. They are computed by an external policy from the disclosed facts, because the criteria on which they depend change over time. See Policy Evaluation.
Group rules (one answer per key, within an interface)
Product rules and per-interface rules each produce a single answer. A product rule answers about the set of interfaces. A per-interface rule answers about one attribute of one interface. Some questions do not have a single answer.
For example, consider whether an interface can be made quantum-safe. A producer may have finished the work on the interface's key agreement, while its identity proof is still waiting on a certificate authority. That producer has two answers, not one. If the profile forces a single answer, the CBOM reports the worse of the two. A planner reading it then concludes that no part of the work can proceed, when in fact half of it can.
A group rule constrains a repeated group of entries. Each entry is identified by a key taken from a controlled vocabulary, and an interface carries one entry per key. The group rule contains member rules, which are evaluated inside each entry. A conditional guard in a member rule (a condition that says when the rule applies) therefore refers to that entry, not to the interface as a whole.
The PQC Migration profile uses a group rule, keyed by cryptographic purpose. Rule pqc-migration#G1 requires an entry per purpose, and its member G1.2 requires a blocker wherever that purpose's status is not available.
A group rule also declares its key coverage (keyCoverage). Key coverage is the set of vocabulary values for which an interface must carry an entry. It may be every value in the vocabulary, or only the values that the profile's scope declares.
The choice of key coverage matters most for a profile that addresses only part of a problem. It decides whether that profile can serve as one depth in a family of profiles, or becomes a permanent floor for the purposes it covers. With full key coverage, the profile still requires a status for each purpose it defers, so a consumer learns where each deferred purpose stands. With key coverage limited to the purposes in scope, the deferred purposes disappear from the document entirely. A later profile then has no baseline (no recorded starting point) to improve on. Conformance requirement C13 checks which key coverage a profile uses. The check is needed because a profile written with either setting loads and runs without error.
Reference rules (pointers to context the document does not carry)
A reference rule requires the document to point to an artefact that it does not carry. Its letter is R. Decision 0020 set the principle for vulnerability statements, and reference rules generalise it: a CBOM records facts that change when the product or deployment changes, and it joins, rather than merges, context that changes on another trigger or that another party holds.
A profile defines its context kinds in contextKinds. For each kind it names the CycloneDX externalReferences types that can carry it, and its form. A document is a fixed artefact, and the pointer binds it by a hash. An endpoint is a feed or API whose content changes, and the pointer names its access protocol. Some kinds accept either form.
| # | Context kind | Level | Applies to | Notes |
|---|---|---|---|---|
| R1 | sbom | MUST | product | The SBOM of the same subject, as a BOM-Link with a SHA-256 hash. |
| R2 | vulnerability-statements | MUST | product | A VEX or CSAF VEX document with its hash, or a feed or API with its access protocol, or the stated absence not-published. Silence fails. |
| R3 | advisories | SHOULD | product | An endpoint with access protocol web-page, csaf-provider, osv-api or ghsa-api. |
| R4 | security-contact | SHOULD | product | Where to report a weakness or ask for a fuller disclosure: rfc-9116 or security-contact. |
| R5 | configuration-guidance | MUST | each interface where I3, I4 or I5 is deployment-defined | Where the operator makes the choice the product leaves open. |
| R6 | design-intent | MAY | any | A threat model or design document. Design intention lives here, not in a lifecycle stage. |
In CycloneDX, each pointer is an external reference with the property pkic:profile:context, which names the kind. Two kinds can share one reference type, so the type alone is not enough. An endpoint also carries pkic:profile:accessProtocol. CycloneDX 2.0 allows properties on external references.
Two principles apply to every reference rule. First, conformance checks the pointer, never the target. The validator checks that the pointer is present and well formed, and checks the hash where it holds the target. It never evaluates what the target says. Second, direction follows time. A record points to artefacts that exist when the producer writes it, such as its SBOM, and to the places where later statements will appear, such as a VEX feed or an advisory API. A judgement made afterwards, such as a conformance claim or a policy result, points to the record by digest. A record never points to a judgement about itself.
The Keycloak product record shows R1 to R5 in use. It cites its SBOM by BOM-Link and hash. It points to a VEX document by BOM-Link and hash. The VEX is illustrative: its identifiers are not CVEs, and upstream Keycloak publishes no VEX, which is why the record exercising the disclosure states states not-published instead. It names the GitHub advisory page and the OSV API. It points to the Keycloak security policy. Its HTTPS listener points to the Keycloak guide for setting the server certificate, and to the same setting in the supplier's machine-readable guidance file. Its management listener points to the guide for the management interface. cbom-keycloak-product-fail-R5.cdx.json removes that guide pointer from the HTTPS listener and fails R5 only. Derived profiles add their own kinds. The deployment profile cites the records it builds on under its P1, with the context cited-document, and adds configuration-source, observation-evidence, data-register and issuer-policy. The PQC migration profile adds support-lifecycle and roadmap. Every document the Keycloak record points to is committed under examples/context/.
Disclosure states
An attribute with no value may be missing for several different reasons, and the profile keeps those reasons apart. Following the 2026 SBOM minimum elements, a producer states whether the information is unknown to it or is being withheld.
| Outcome | Meaning | Effect on a MUST rule |
|---|---|---|
value | A value was supplied and checked against the constraint. | Passes if valid. |
withheld | The producer holds the information and declines to publish it. | Passes only where the rule is marked withholdable. |
unknown | The producer does not have the information. | Fails, but is reported as unknown rather than absent. |
undeclared | Neither a value nor a marker was supplied. | Fails. |
An unknown value does not satisfy a MUST rule at any stage, because the requirement has not been met. A record with gaps conforms one depth down, at the entry profile, instead: cbom-keycloak-deployment-observed-fail-unknown.cdx.json reports the database group as unknown, fails baseline I3, and conforms to Interface Enumeration. The validator still reports an unknown value separately from an undeclared one. An unknown marker records a limit of the producer's process. An undeclared attribute records that the producer never addressed the question.
In this profile only I9 is withholdable. I9 is withholdable because a producer can decline to publish a library version and still meet part of the purpose of the disclosure. The verdict stays "conforms", and the report shows the withholding. The PQC migration and procurement profiles both make I9 non-withholdable. cbom-keycloak-product-disclosure-states.cdx.json shows all four outcomes: its withheld library is permitted, and it fails I5 on the cluster interface (unknown) and I4 on the SAML interface (undeclared).
The choice of which rules are withholdable also decides a larger question. It decides whether a public document can conform to the profile, or whether only a document released under an agreement can conform. Confidentiality covers that question. One kind of consumer, the vulnerability responder, cannot accept a withheld I9 at all. Incident response depends entirely on matching a library against a vulnerability feed. If I9 is withheld, the responder has no library to match. For that reason, Vulnerabilities treats the withholding of I9 as the open question that blocks that use case. See Challenges and Demo.
Composition: how profiles relate to each other
People mean two different things when they talk about combining profiles. Keeping the two apart matters, because they carry different guarantees.
Independent evaluation
A CBOM may be evaluated against any number of profiles, each producing its own verdict. The profiles need not know of each other and are not combined. This is how one document serves several purposes. A vendor publishes the CBOM once. A procurement team, a migration planner and a vulnerability responder then each apply the profile that matches the decision they have to make.
Independent evaluation depends on two conditions. First, attribute names are global across the methodology, so a name means the same thing in every profile that uses it. That is why the naming conventions and the attribute table in Terms apply to all profiles rather than to each one in isolation. Second, a verdict is always reported per profile, so conformance to one says nothing about another.
Extension
A profile may declare that it extends another. It then inherits every rule of the base and states only what it adds or changes. A sector baseline built on a general one is of this kind. So are the three example profiles built on the interface disclosure baseline v0.9: PQC migration v0.8, procurement v0.1 and deployment disclosure v0.2. PQC migration extended v0.1 extends PQC migration v0.8 in turn.
Extension is monotonic. A derived profile may add rules and tighten inherited ones. It may not relax them. This restriction guarantees the property that makes extension useful: a document that conforms to the derived profile also conforms to the base. Without the restriction, a claim of conformance to a sector profile "based on" the baseline would tell a consumer nothing at all about the baseline, and the word "based" would mislead the consumer.
| Operation on an inherited rule | Permitted | Why |
|---|---|---|
| Raise the level, SHOULD to MUST | yes | Tightening. Anything satisfying the derived rule satisfies the base rule. |
| Narrow a constraint, such as restricting an enumeration to a subset or raising a minimum count | yes | Tightening. Each kind of constraint is compared with the same kind of constraint in the base. An override (a derived profile's change to an inherited rule) that carries a constraint the comparison does not recognise is refused rather than assumed safe. |
| Add a constraint the base did not carry, such as requiring an identifier form where the base required only presence | yes | Tightening. Recorded as a composition note, so a reader of a report can see what the derived profile added. |
| Drop a constraint the base carried, or replace an identifier-form requirement with a bare presence check | no | Relaxation. This is the relaxation most easily written by accident, because the rule still appears to be present in the file. |
| Make a withholdable attribute non-withholdable | yes | Tightening. |
| Add a new attribute or structural rule | yes | Extension proper. |
| Lower the level, MUST to SHOULD | no | Relaxing. Breaks the implication that derived conformance means base conformance. |
| Widen a constraint or remove a rule | no | Relaxing, on the same grounds. |
| Make a non-withholdable attribute withholdable | no | Relaxing. |
| Add a value to an inherited vocabulary that keys a group, such as a cryptographic purpose | yes | Extension. The added value carries the derived profile's rules only. The base never asks for an entry under it, so a document that conforms to the derived profile still conforms to the base. |
Add a value to an inherited vocabulary that constrains an attribute value, such as interfaceType | no | Relaxing. The derived profile would accept a value the base rejects. |
| Redefine what an inherited attribute means | no | Names are global. A profile needing different semantics needs a different attribute. |
A profile that genuinely needs to relax a base requirement is not an extension of that base. It is an independent profile, and it should be written and claimed as one. The methodology treats this as a firm rule, not as an inconvenience to work around. Holding to the rule keeps conformance claims meaningful.
Two things extension is used for
Extension expresses two different intentions. If the two are confused, it becomes hard to discuss what a derived profile is for.
Depth. The derived profile asks for more detail about the same subject matter. The migration profile relates to the baseline in this way. It covers the same interfaces and describes them more fully.
Coverage. The derived profile brings more subject matter into scope, at the same level of detail. A profile covering key establishment, later extended by one that adds entity authentication, is of this kind. Here the rules often do not change at all. They are written once and applied to whichever purposes the scope declares. The two profiles then differ only by one line in their scope declaration, not by a second set of rules.
Both kinds of extension are monotonic and both are permitted. The distinction matters when a family of related profiles is planned, because depth and coverage are added at different times. Depth is added when producers are able to supply the extra detail. Coverage is added when consumers need the extra subject matter. Stating which of the two a derived profile adds avoids a later argument about why the profile exists.
Widening a vocabulary
A sector profile may need a cryptographic purpose the base does not define, such as attestation, tokenization or credential verification. It can add one. The added purpose keys new entries under G1, and only the derived profile has rules for those entries. A consumer holding the base evaluates the same document and never asks for them, so conformance still carries downwards.
The same is not true of a vocabulary that constrains an attribute value. Adding telemetry to the interface types would let a document pass the derived profile with an interface type the base rejects. A derived profile may therefore add values only to a vocabulary that keys a group. Every other vocabulary may only narrow. check_profile.py enforces this under C7. The rule is provisional and is recorded in decision 0025.
Pinning, ranges and identifiers
- The base version is pinned. A derived profile names the base profile and the exact version it extends. A later release of the base has no effect until the derived profile's author re-pins and re-checks, which follows the general treatment of profile versions in Versioning.
- Accepted subject types and stages may narrow, never widen. The baseline accepts the subject types
productanddeploymentand the stagesimplemented,configuredandobserved. PQC migration and procurement narrow both to a product atimplemented. Deployment disclosure narrows them to a deployment atconfiguredorobserved. - The carrier acceptance range may narrow, never widen. The carrier acceptance range is the range of document format versions a profile accepts. A derived profile cannot accept a format version the base excludes, since the base's adapter may be unable to read it.
- Inherited rules keep the identifiers the base gave them. A report can then trace any failure to the profile that imposed it. See Rule identifiers for how identifiers are allocated.
- An inherited group can be tightened without restating it. A derived profile may tighten one member of a group it inherited, naming that member by its qualified id (
pqc-migration#G1.3), and may widen the group'skeyCoverage. Members it does not name are inherited unchanged, and so is the key vocabulary. Restating the whole group would discard both the unchanged members and the key vocabulary. A restated group would also silently replace the base's coverage. Coverage may be widened and never narrowed. See decision 0014. - A guard may be removed, but not added or changed. A
requiredWhenguard says when a rule applies. Removing it makes the rule apply always, which is a tightening. Adding one where the base has none makes the rule fire less often, and narrowing an existing guard does the same. This is the relaxation that is hardest to spot by reading, because the rule stays listed and stays in every report, but quietly stops applying. Adding a guard and narrowing a guard are both refused. - Single inheritance only, for now. A profile extends at most one base. Multiple inheritance raises conflicts between bases that would need resolution rules, and no case requiring it has arisen.
Rule identifiers
A rule identifier is local to the profile that declares it. The citable form is the profile's tag (its short name) followed by the identifier, for example interface-disclosure#I9. No shorter form names a rule. Several profiles in one family may each declare an I1, and in the example family five of them do.
The letter in an identifier shows which kind of rule it is and how often the rule is evaluated. It is fixed by the section the rule sits in rather than chosen by the author. P means once per document, I once per declared interface, G once per entry in a group, with members numbered under their group as G1.2, and R a reference rule, evaluated once per document or once per interface as the rule states. Numbering restarts at 1 in every profile, at every level of a family.
This scheme has two consequences.
- A rule keeps the identifier of the profile that introduced it, however far down the family it is later tightened. The migration profile makes the baseline's
implementationPurlrule non-withholdable, but that rule is stillinterface-disclosure#I9. The tightening is recorded againstinterface-disclosure#I9, and a report names both the rule and the profile that tightened it. - The tag is the only thing that has to be unique along a chain of profiles. Because only the tag must be unique, a base profile can add a rule without first checking which identifiers its derived profiles already use. For the same reason, a family can go three levels deep with no reserved ranges of numbers and no registry. A tag that an ancestor already uses is rejected before any document is evaluated.
Identifiers are not reused. Once a version is released, an identifier retired in a later version stays retired, and the numbering carries a gap. The reason is that a conformance report or a stored claim may cite that identifier against a document evaluated under the earlier version. Reusing it would make the old report silently wrong, rather than merely out of date.
Identifiers do not appear in CBOM documents at all. They appear in conformance reports and in claims, which is why they have to be stable and why they have to say which profile they came from. See decision 0011.
Expressing a conformance claim
A conformance claim is the artifact that passes from one organisation to another. A producer hands the claim to a consumer who was not present when the evaluation ran, and who may read it months later. The claim is a machine-readable document with its own schema. The shape below is illustrative. claim-example.json is a real claim about the Keycloak product record. It covers three profiles at once: the baseline, PQC migration and PQC migration extended.
Four properties make a claim checkable. A claim is bound to one document by digest (a hash of the document), so the claim no longer matches if it is placed beside a different CBOM. It lists every profile separately, with its own verdict and its whole pinned chain, because a document can conform to one profile and fail another. It carries the disclosure states alongside the verdict, because “conforms” with the implementing library withheld is a different answer from “conforms” with it supplied. And the claim itself lists what it does not assert, rather than referring to another document for that list. See decision 0015.
Document: cbom-keycloak-product.cdx.json (sha-256 1b8fff9d...)
Conforms to:
pkic.example.pqc-migration v0.8 (tag: pqc-migration)
extending pkic.example.interface-disclosure v0.9 (tag: interface-disclosure)
pkic.example.interface-disclosure v0.9 (independently evaluated)
Carrier: CycloneDX 2.0
Content revision: 1
The tags have a function in the claim. A report attached to the claim cites rules as pqc-migration#I4, and a reader needs the claim to say which profile that tag belongs to.
A claim is useful only if a consumer can re-check it. A consumer holding the claim and the document runs validate_cbom.py <cbom> <claim> --verify-claim. The command confirms the digest, re-runs every profile the claim names, and reports where the claim and the new results disagree. A mismatch exits with 5 rather than 1, because a mismatch is a finding about the claim, not a verdict on the document. Someone holding a bad claim and a good document should evaluate the document. An exit code meaning “does not conform” would wrongly point them at the document.
A claim about a deployment record depends on the records it cites. If the evaluator was not given a cited record, it reports each rule that depends on an inherited value as unresolved, and the claim lists those rules under unresolved. The claim's notAsserted list also says that it asserts nothing about them.
Verification cannot establish that the disclosed values are true. A producer who states TLS 1.3 for an interface actually running TLS 1.2 produces a claim that verifies perfectly. The claim's own notAsserted list states this limitation, and the list will always include it. Proving that values are true is attestation, which is a different problem. If the claim format implied that it provided attestation, that would be the most damaging error it could make.
Machine-readable form
A derived rules file declares its base and lists only its additions and its tightenings.
{
"profileId": "pkic.example.pqc-migration",
"profileTag": "pqc-migration",
"version": "0.8",
"extends": { "profileId": "pkic.example.interface-disclosure", "version": "0.9" },
"scope": { "subjectTypes": ["product"], "lifecycleStages": ["implemented"], ... },
"overrides": [
{ "id": "interface-disclosure#I9", "level": "MUST", "withholdable": false }
],
"interfaceRules": [ ... numbered from I1 in this profile's own space ... ]
}
The override names its target in full. A bare I9 would be this profile's own ninth interface rule, which is a different rule, so the validator rejects an unqualified override rather than guessing.
A validator loading such a file resolves the base, applies the overrides, and rejects any override that relaxes an inherited rule. That check is worth implementing early, because a relaxing override is easy to write by accident and its effect on a conformance claim is not obvious from reading the file.
What “relaxes” means for a constraint. Comparing obligation levels is easy. Comparing constraints is harder, and it decides whether the guarantee that derived conformance implies base conformance actually holds. Each kind of constraint is therefore compared on its own terms. A minimum may rise and not fall. A list of permitted values may shrink and not grow. A required prefix may lengthen and not shorten. An override may add an obligation the base did not carry, but may not drop one it did. Changing which attribute a rule is about is not an override at all. It is a different rule, and a derived profile adds it under its own id.
The most important rule covers a constraint that the comparison does not recognise. An override carrying such a constraint is refused, rather than assumed to be monotonic. A checker that passes what it cannot assess produces the same green report as a checker that has actually checked. Wrongly passing an override in this way is a worse failure than wrongly refusing it. See decision 0013.
Conformance pipeline
The validator takes a CBOM and applies its stages in sequence: the format gate, the product rules, the document-level reference rules, the interface rules with their interface-level reference rules, and the verdict. It evaluates the content stages only if the format gate accepts the CBOM. The format gate accepts CycloneDX 2.0 as the target, reads 1.6 and 1.7 as legacy, accepts a version above 2.0 with a note, and refuses anything below 1.6.
A deployment record cites the records it builds on. When the caller supplies them with --with, the validator checks each citation's serial number, version and SHA-256 hash, and resolves inherited facts through the join. When the caller does not supply them, the validator reports each inherited value as OPEN (unresolved) rather than failed.