CBOMProfiles /Methodology ← Working group site
CORE

Conformance

Conformance is the relation between a document and the rules it is checked against. The Profile section gives the rules of one example profile. Conformance covers what can be assessed, who may claim conformance, how a claim is written down, and what a claim does not cover.

Requirement keywords

The keywords MUST, MUST NOT, SHOULD, SHOULD NOT and MAY are to be interpreted as described in BCP 14 (RFC 2119 and RFC 8174) when, and only when, they appear in capitals. The same keywords in lower case carry their ordinary English meaning and impose no requirement.

What can be assessed

Three different things can be assessed, and each is assessed against its own criteria. A claim that does not say which of the three it means is ambiguous. Saying that something "is conformant", without naming what was assessed, is not a conformance claim under this methodology.

TargetAssessed againstAssessed byResult
A CBOM document
a specific revision of a specific document
A specific version of a specific profile A validator, mechanically Conforms · Does not conform · Refused
A profile
the rules document itself
This methodology Review, with mechanical checks on the rules file Well-formed · Not well-formed
An evaluation tool
a validator implementation
This methodology's evaluation semantics A conformance test suite Conforms · Does not conform

The three assessments depend on each other, and the dependency runs in one direction only. A verdict is the result of assessing a document against a profile. A verdict is meaningful only if the tool that produced it conforms to this methodology, and only if the profile used is well-formed. A document assessed by a non-conforming tool therefore has no established verdict. A verdict against a profile that is not well-formed establishes nothing either, because the rules used to measure the document were not valid rules.

1. A CBOM document conforming to a profile

A CBOM document conforms to a profile version when all of the following hold.

Rules at SHOULD and MAY level are evaluated and reported, but they do not decide the verdict. If an author wants a requirement to decide the verdict, the author states it at MUST level. A consumer may sometimes treat a SHOULD rule as binding anyway. That consumer has misread the profile. If the author meant MUST, the fix is for the author to raise the rule to MUST level.

Verdict vocabulary

VerdictMeaningWhat it says about the document
ConformsEvery MUST rule is satisfied, at a carrier version within the acceptance range.The document discloses at least what the profile requires.
Does not conformAt least one MUST rule is not satisfied.The document was assessed and found short. The report identifies each failing rule.
RefusedThe carrier version falls below the profile's declared minimum.Nothing. No assessment was performed, because the profile cannot express its rules against that carrier version.

Refusal and non-conformance are reported separately and MUST NOT be merged. A refused document may be perfectly adequate. The profile is simply unable to say so, because it cannot express its rules against that version of the carrier format. Treating a refusal as a failure penalises a producer because its document uses an older format version, not because of what the document discloses.

Effect of the disclosure states

Every attribute is assessed according to which of the four outcomes applies to it. The states are defined in the Profile section and are summarised here for their effect on a verdict.

OutcomeAgainst a MUST ruleAgainst a SHOULD or MAY rule
valueSatisfied if the value meets the constraintReported; satisfied if the value meets the constraint
withheldSatisfied only where the rule is marked withholdable; otherwise not satisfiedReported as withheld
unknownNot satisfied, and reported as unknown rather than as absentReported; does not affect the verdict
undeclaredNot satisfiedReported; does not affect the verdict

A document can therefore conform while withholding some values. A consumer who reads only the verdict will not know that values were withheld. For this reason a conformance report states the disclosure state of every rule it assessed. A consumer who acts on the verdict alone ignores the part of the result that is most likely to matter commercially. The clearest example is a public variant and a restricted variant of the same document. Both variants conform, but only one of them answers the consumer's question. See Confidentiality.

Records that cite other records

The vendor writes the product record, at the implemented stage. The operator writes deployment records, at configured and observed. Each record has one subject and one stage. A deployment record does not restate the vendor's build facts. It cites the records it builds on, each by a BOM-Link (urn:cdx:<serial>/<version>) and a SHA-256 hash. Each of its interfaces names the interface it realises with pkic:profile:correspondsTo, or states no-product-document where the supplier publishes no CBOM. See Model and decision 0025.

A verdict on a deployment record depends on what the evaluator was given.

One rule has a route that depends on a cited record. At observed, baseline P2 passes when a cited configured record declares a management interface that the observer could not reach. An observer with nothing to cite, such as an outside assessor, states not-reached instead, and the validator accepts that reason only with coverage partial.

Conformance to more than one profile

A document evaluated against several profiles receives one verdict per profile. A verdict against one profile implies nothing about conformance to any other profile. There is one exception. Where one profile extends another, conformance to the derived profile also implies conformance to the base profile version that the derived profile pins, meaning names by identifier and version. This holds because extension is monotonic: a derived profile cannot relax an inherited rule. See the composition rules in Profile.

Scope of a verdict

A verdict applies to one revision of one document, assessed at a point in time. It does not extend to later revisions, to other documents describing the same product, or to the product itself. A product does not conform to a profile; a document describing it does.

2. A profile conforming to this methodology

A profile is well-formed under this methodology when it satisfies the following. Each requirement restates, as a requirement, an output that the procedure in Method produces.

#RequirementLevel
C1The profile states the consumer it serves, the decision it supports, and the options the consumer chooses between.MUST
C2The profile carries an identifier and a version, and declares an acceptance range for every carrier format it supports.MUST
C3No rule refers to a named product, vendor, or interface instance.MUST
C4Every rule carries a stable identifier, an obligation level, and a statement of whether withholding satisfies it.MUST
C5Attribute names follow the methodology's naming conventions, and any attribute already defined elsewhere in the methodology is used with its established meaning.MUST
C6No rule requires a derived judgement whose criteria are external to the document and subject to change. See Policy Evaluation.MUST
C7Where the profile extends another, it pins the base by identifier and version, and no override relaxes an inherited rule. It adds values only to an inherited vocabulary that keys a group.MUST
C8The profile states what it deliberately excludes, and why.SHOULD
C9The profile is accompanied by a mapping to at least one carrier format, and by at least one document that conforms and one that does not.SHOULD
C10The profile carries a changelog classifying each change as tightening, relaxing, or editorial.SHOULD
C11The profile declares its scope: the subject types it accepts, its orientation, the relationship types its rules constrain, and the lifecycle stages of reported data it accepts.MUST
C12The rules the profile imposes are consistent with the orientation it declares.MUST
C13Every group rule is keyed to a declared vocabulary, and a profile that declares a subset of that vocabulary in scope still requires an answer for the rest.MUST
C14Identifier schemes are declared for every asset class the rules constrain, and no scheme is declared that no rule applies.MUST
C15The profile carries a tag, and no profile it inherits from already uses that tag.MUST
C16Rule identifiers are local to the profile, and each carries the letter of the section it sits in.MUST
C17Every rule can pass a document and can fail one: it has a constraint, the constraint is one the evaluator implements, and any vocabulary it names is declared.MUST
C18Every reference rule names a context kind that the profile or its base defines, and that kind is carried by real CycloneDX reference types.MUST

C3, C6 and C7 are the requirements that review most often has to enforce. Each can be broken by a rules file that still loads and runs without errors. For example, a profile that names a particular instance still evaluates documents without error. However, it evaluates them for that one deployment rather than for the product.

The scope declaration

C11 requires the scope to be declared as one object, rather than as separate fields scattered through the profile. The reason is that the subject types, the relationship types and the accepted lifecycle stages together describe a single boundary. Step 2 of Method decides all of them at once.

MemberValuesWhat it settles
subjectTypesa set drawn from product, deployment, service, component, system, estate-subsetWhich kinds of subject the profile applies to. The example baseline accepts product and deployment, because its rules describe an interface the same way for both. A derived profile narrows the set, as it narrows the stages: PQC migration and procurement accept product, and deployment disclosure accepts deployment. Each document then declares its own subject type, and the validator compares the two. The older single subjectType field is read as a set of one.
relationshipTypesthe relationship types named in Model; today only interfaceWhich kinds of cryptographic relationship the rules constrain. The profile declares these types, and the checker compares the declaration with the rules instead of trusting it. A scope statement that no longer matches the rules still reads as authoritative, so it is worse than no statement at all.
orientationinventory, migration, bothWhether the profile reports what an interface does, what it could do, or both. The value is more than a label, because C12 requires the rules to be consistent with it. It uses the same vocabulary the working group uses for its own aspects, except for n-a.
lifecycleStagesa subset of intended, implemented, configured, observedWhich stages of reported data the profile will accept, in the same sense that appliesTo settles which carrier versions it will accept. A document has one stage, carried in metadata.lifecycles. An interface reporting a stage outside the set fails the rule that constrains the stage.

Of the members, subjectTypes and lifecycleStages are the ones that change verdicts. Without lifecycleStages, a document could report every interface at the intended stage and still conform. Such a document would describe cryptography the producer plans to build, not cryptography that exists.

In the example family, the entry profile, Interface Enumeration, accepts all four stages, because a first inventory takes whatever a producer can report. The disclosure baseline does not accept intended, because a design intention answers nothing about deployed interfaces. A vendor's intention belongs in a capability status, an operator's intention in a policy or tender, and a design document in a pointer under baseline R6. PQC migration and procurement accept only implemented. Deployment disclosure accepts only configured and observed. A derived profile may narrow the set of accepted stages and subject types. It may not widen either set, for the same reason that it may not relax a rule.

Orientation, and why it is checked rather than taken on trust

A document can describe both the present state of an interface and its declared capability. Both appear in the same document, about the same interface, under attribute names that differ only by a suffix. keyExchange is the key exchange an interface negotiates today. keyExchangeSupported is every key exchange it could negotiate.

The naming conventions in Method keep the two names apart. They do not keep the two obligations apart. A profile could require only the capability attribute. A consumer would then hold a set of supported algorithms with no way to tell which one is in use, and would be likely to misread the document.

C12 closes that gap by setting an obligation for each orientation.

OrientationThe profile's rules must
inventoryRequire no forward-looking attribute: nothing with a Supported suffix, and none of capabilityStatus, blockedBy or roadmapRef.
migrationRequire at least one, or the profile reports present state only and is an inventory profile under another name.
bothRequire, for every capability attribute, the present-state attribute it is a capability for.

C12 is assessed against the resolved profile, which is the profile together with the rules it inherits from its base. A rule inherited from a base can therefore satisfy C12. This is the normal case, not a loophole. The example migration profile declares the three capability attributes itself, and inherits their present-state counterparts from the baseline it extends. A profile that declared both but required only capability attributes would fail C12. That is the case the requirement exists to catch.

Group rules, and why coverage is checked

A rule normally constrains one attribute of one interface. A group rule is different. It constrains a repeated group of entries, keyed by a controlled vocabulary, so that an interface gives one answer per key instead of one answer overall. The migration example uses a group rule for capability. An interface states its status separately for each cryptographic purpose, because key agreement and identity proof migrate on different timetables. A single status would have to report the worse of the two.

Two properties of a group rule are checked. Without these checks, each property has a failure mode that would go unnoticed, because the rule looks ordinary in the file and the report shows it passing.

The first failure mode is a group rule keyed to a vocabulary that the profile never declares. Such a rule requires an entry for no keys at all. Every document therefore satisfies it, and the report shows it as passing. C13 rejects the profile instead of issuing that verdict.

The second failure mode is a group rule whose keyCoverage is set to in-scope while the vocabulary it is keyed to contains more keys than the profile takes in scope. That setting lets a profile defer part of the problem and never return to it. A family of depths is meant to control how much detail an answer carries at each depth. It is not meant to remove the question. A purpose that the profile has deferred still requires a status. It also requires a blocker wherever that status is not available. Without that requirement, a supplier could conform while acting as though a whole class of cryptography did not exist. Each depth would then become a permanent floor instead of a step towards the next depth. C13 makes this difference checkable.

Identifier schemes

When an inventory is built from CBOMs supplied by several suppliers, the consumer has to work out which records describe the same thing. Identity cannot be settled in general, because some classes of asset have no agreed identifier at all. It can be settled one profile at a time, and that is the means this methodology has available. A profile names the identifier form it requires for each class of asset that its rules constrain. A consumer then knows which naming scheme the document uses.

C14 does not check that a value really belongs to a registry. The checker does not hold a copy of the registry, so any such check would be a guess. Instead, C14 checks that the declaration and the rules agree in both directions. Every scheme a rule references must be declared, and every declared scheme must be referenced by some rule. A declared scheme that no rule applies can drift away from what the profile actually does, while still reading as authoritative. A profile has to state which registry it means. For algorithm names, the methodology uses the file format's registry, which for CycloneDX is the Cryptography Registry, where an entry exists. Where none exists, the producer uses the name from the protocol's own registry.

C15 and C16: identifiers that can be cited

A rule identifier is local to the profile that declares it. A rule is therefore cited as <profileTag>#<ruleId>, and three profiles in one family may each declare their own I1. This approach moves the uniqueness requirement off the rule identifiers and onto the tag. No author can coordinate rule identifiers across a whole family, but an author picks a tag only once. C15 checks that the tag is unique. Without C15, a citation could resolve to two different rules, and a stored conformance claim would no longer identify which rule it refers to. With C15, a base profile can add a rule without first checking which identifiers its derived profiles already use.

C16 fixes the meaning of the letter in a rule identifier, so that the author does not choose it. P means the rule is evaluated once per document, I once per declared interface, G once per entry in a group, and R once per document or once per interface, as the reference rule states. The tag already says which profile a rule belongs to, so the letter can tell the reader how often the rule is evaluated. C16 does not require the numbers to run without gaps. A released identifier is never reused, so gaps are expected. A checker that demanded a contiguous sequence would forbid exactly what the no-reuse rule exists to allow. See decision 0011.

The claim: the artifact read without the inputs

Two of the conformance targets are checked by someone who holds the inputs: a document against a profile, and a profile against the methodology. The claim is a separate artifact. It is the only one read by someone who does not hold the inputs. That reader is typically a buyer in a different organisation, reading the claim months later.

A claim is a machine-readable document. It is bound to one CBOM by digest. It lists every profile that was evaluated, each with its own verdict and its whole pinned chain of base profiles. It also carries the disclosure states and the non-assertions inside itself, rather than pointing to them elsewhere. The non-assertions are the statements of what a verdict does not establish.

The non-assertions matter most. Every point in the table under What a conformance verdict does not assert is repeated inside every claim. The reason is that the person reading a claim will not have read the methodology, and the word “conforms” invites more inference than it supports.

A claim can be re-checked. Running --verify-claim confirms the digest and re-runs each profile the claim names. Re-checking cannot establish that the disclosed values are true, and no future version of the check will be able to. A producer who misstates a protocol version still produces a claim that verifies correctly. See decision 0015, and 0016 for what an SPDX-only claim may assert.

C17: rules that cannot fail

A rule that cannot fail is worse than a missing rule. The report says the rule passed, and a reader cannot tell that it could never have failed. There are three ways to write such a rule, and until recently all three passed review.

C13 already rejected the third case for group keys. C17 covers the remaining cases. The validator refuses a profile that breaks C17, instead of issuing a verdict against it.

C17 applies the principle behind C13 more widely: every rule in a profile must be capable of failing a document. C17 is written as a requirement, rather than left to review, because none of the three defects is visible when you read the file. Each defect produces a rule that looks ordinary.

C18: reference rules that point at something real

A reference rule names a context kind, such as sbom or configuration-guidance. The profile defines each kind once, in contextKinds, with the CycloneDX reference types that can carry it and its form: a fixed document bound by a hash, or an endpoint that names its access protocol. C18 requires every reference rule to name a defined kind, and every kind to list real CycloneDX reference types. A kind whose carrier list names no real type could never be satisfied by a valid document, so the rule could only fail.

C1 to C7 and C11 to C18 are checked mechanically by check_profile.py, which takes a rules file and reports on each requirement in turn. C8 to C10 are checked where the profile declares the material, and are reported as warnings that do not affect the result unless --strict is given.

All six example profiles pass: Interface Enumeration v0.3, the Interface Disclosure Baseline v0.9, Deployment Disclosure v0.2, PQC Migration v0.8, PQC Migration Extended v0.1 and Procurement v0.1. The test suite also carries deliberately defective profiles for the MUST requirements, so that the checks themselves are tested.

The tool does not replace review. C3 in particular is enforced through indirect structural checks. A rule that names a specific instance in a way the checker does not model would therefore still pass.

3. An evaluation tool conforming to this methodology

Two tools given the same document, the same profile, and the same resolution of any extended base should return the same verdict. The requirements below are what that expectation rests on.

#RequirementLevel
T1Determine the carrier band, meaning which of the profile's version ranges the carrier version falls in, before evaluating content, and refuse a document below the declared minimum without issuing a conformance verdict.MUST
T2Report the four disclosure outcomes distinctly, and not collapse withheld, unknown and undeclared into a single absent state.MUST
T3Resolve an extended base and reject, before evaluating any document, a profile containing an override that relaxes an inherited rule.MUST
T4Report, for every rule assessed, its identifier, the profile that imposed it, its obligation level, and the outcome.MUST
T5Distinguish, in whatever channel the caller consumes, between a conformance failure and an invalid profile.MUST
T6Evaluate rules at SHOULD and MAY level and report them without allowing them to determine the verdict.MUST
T7Produce identical output for identical inputs, with no dependence on ordering within the document.SHOULD
T8Apply the profile's accepted lifecycle stages, and reject, before evaluating any document, a derived profile that accepts a stage its base rejects.MUST
T9Distinguish, when a stage is rejected, a stage the methodology defines that this profile does not accept from a value that is not a stage at all.SHOULD

The reference validator signals T5 through its exit code: 0 for conforms, 1 for does not conform, 2 for a usage error, 3 for a profile error such as a relaxing override, 4 for a refusal, and 5 for a claim that does not match a re-run evaluation.

Exit code 4 exists because of T1. A caller that cannot tell a refusal from a failure will reject a producer because of the age of its carrier format.

Until August 2026 the validator printed DOES NOT CONFORM and exited 1 on a refusal. It merged the two results that must not be merged. The test suite asserted that exit code, so the test held the defect in place instead of catching it.

The methodology requires only that the distinction between the two results reaches the caller. The particular codes are an implementation choice, and another tool may signal it differently.

validate_cbom.py is the reference implementation. The Demo page used to be a second one: a static page cannot run Python, so the evaluation was written again in JavaScript, and tests/check-demo.py compared the two. The demo and the reference tool had diverged once before that check existed. A published page that silently disagrees with the specification is worse than no page at all.

The demo no longer evaluates anything. tools/build_demo_reports.py runs the validator over the examples and writes demo-reports.json, and the page renders that file. tests/check-demo.py regenerates the reports and fails if the committed file differs. It also fails if the page holds a copy of any rules file. This changes how decision 0018 is met, not what it requires: the page shows what the reference tool says.

Making and recording a claim

A conformance claim is a statement by an identified party that a named document revision was assessed against a named profile version and produced a stated verdict.

What a claim cites

A claim names three things: the profile and its version, the carrier format and its version, and the content revision of the document that was assessed. A claim missing any of the three cannot be reproduced, and a claim that cannot be reproduced cannot be audited. Where a derived profile was used, the claim also names the base and the version it pins.

Document: cbom-keycloak-product.cdx.json  (Keycloak 26.7.3 product record)
Conforms to:
  pkic.example.pqc-migration v0.8
    extending pkic.example.interface-disclosure v0.9
Carrier: CycloneDX 2.0
Content revision: 1
Assessed by: Example Ltd (self-declared)
Assessed on: 2026-10-25
Tool: validate_cbom.py

A claim about a deployment record also lists, under unresolved, every rule the evaluator could not settle because it was not given a cited record. claim-example.json is a complete claim.

Who may claim

A claim is made by the party that performed the evaluation, and identifies that party. A producer evaluating its own document makes a self-declared claim, which is permitted and is labelled as such. A claim made by a party other than the producer is an attested claim, and carries whatever additional weight the relying party assigns to the attesting party.

Validity over time

A claim is fixed to the revision it assessed and does not roll forward. A new content revision needs a new evaluation. So does a new profile version, and where that version tightened a rule, a document that conformed before may no longer conform. The changelog is what tells a producer whether re-evaluation is likely to be needed, and that is why the methodology asks for every change to be classified.

What a conformance verdict does not assert

The verdict is a statement about disclosure only. It does not make the following claims, although it is often mistaken for them.

A verdict of "conforms" does not assertBecause
That the disclosed values are accurateAccuracy is a property of the producing process. Signing establishes origin, and the lifecycle stage records how the data was obtained. Neither is checked by the profile.
That the disclosed values are currentA CBOM revision is a point-in-time record. A configured or observed value may have changed since capture.
That the cryptography described is adequateAdequacy is a derived judgement made by external versioned policy, deliberately kept out of the document. See Policy Evaluation.
That the document is completeA profile is a minimum reporting requirement. Cryptography outside the profile's scope may exist and is not required to be disclosed.
That every relevant interface was declaredA product rule requires the document to account for each kind of interface it names: the document declares one, or states that there is none. The coverage statement (P4) says how complete the declared set is. An interface of a kind that no product rule names is invisible to the evaluation. A verdict also does not check that a statement of absence is true. A false one is a misstatement by the producer.
That the cryptography described is free of known vulnerabilitiesA third party asserts a weakness about a component. Whether the weakness affects this product is a judgement the producer publishes separately, as a VEX statement. A profile requires the facts that let a consumer join the weakness to the VEX statement. The baseline also requires a pointer to where the producer publishes such statements, or a statement that it publishes none (R2). It does not require a verdict on vulnerability. See Vulnerabilities.
That an artefact the document points to is correct, current or reachableA reference rule checks the pointer, never the target. Where the evaluator holds a cited document, it checks the hash, and nothing more. The content of an SBOM, a VEX feed or a configuration guide is outside the verdict.
Anything inherited from a cited record the evaluator was not givenThe validator reports such a rule as unresolved, and the verdict does not count it. A consumer who needs it settled supplies the cited record and evaluates again.
That the product is suitable for a given purposeSuitability is the consumer's decision. The profile exists to supply the facts that decision needs.

The rows on completeness and on undeclared interfaces are the ones most likely to cause trouble in procurement. Both allow a document to conform while leaving out something the buyer assumed was covered. The remedy is in the profile author's hands: write product rules strong enough that the omission fails the evaluation. This is a drafting question, and the conformance semantics do not need to change to deal with it.

PKIC CBOM Profiles Working Group · draft for comment.