Conformance
This page is normative
This page is considered a core part of the Vultron Protocol. This is a normative section of the documentation.
The whole specification on one page
The specification is also published as a single page that holds every section and annex in order, for printing or for searching the whole text at once.
This page holds section 13 of the Vultron Protocol Specification: what an implementation claims when it claims conformance, and how that claim is tested. A conforming participant maintains the Report Management (RM), Embargo Management (EM) and Participant Embargo Consent (PEC) state machines, and the Case State (CS) dimensions. Not every role applies to every participant: only a participant that holds the optional Common Vulnerabilities and Exposures (CVE) Numbering Authority (CNA) role assigns CVE identifiers itself.
13. Conformance [N]
13.1 Conformance Model Overview
Conformance is two-dimensional: capability sets (what protocol machinery an implementation provides) and a role profile (which roles it claims). A conformance claim names capability sets and roles directly:
CapabilitySet [+ CapabilitySet ...] / Role [+ Role ...]
Examples: Case Observer / Reporter, Case Observer / Vendor, Case Observer / Vendor + Deployer, Case Observer + Case Decision + Case Hosting / Coordinator + Case Owner.
Every claim includes the Case Observer capability set, because every case participant provides it (§13.2 Capability Sets). Role obligations are additive and orthogonal: no role subsumes another.
Capability set names and role names come from §13.2 Capability Sets and §13.3 Role Taxonomy respectively.
Roles and capability expectations. The relationship between roles and capabilities goes both ways. A role assumes the capabilities that its obligations need (§13.3.1 Process Roles). Conversely, holding a role in a case creates an expectation that the implementation has those capabilities, and other participants act on that assumption. §12.1 Role Assignment gives the rules for granting a role.
Capability sets are not the same as conformance test layers
This project uses two distinct schemes, and they answer different questions:
- Capability sets, defined here, describe what an implementation provides — a claim an implementer makes about their software.
- Conformance test layers (L1–L4), used in the behavioral conformance material, describe what a test verifies — syntax, semantics, behavior, and internal process structure.
These are orthogonal: a Case Observer implementation is tested at layers L1 through L3. A conformance claim names capability sets; a test result names a layer. The two are not interchangeable.
13.2 Capability Sets
A capability set is a named group of the obligations that an implementation takes on. Where an obligation is a protocol requirement, this section renders it as a callout; the others link the section that describes them. Three are defined. Case Observer is the set that every participant provides. Case Decision and Case Hosting add the requirements of deciding for a case and of running one. The Case prefix marks each as a capability set — a property of software — distinct from the similarly-named roles it serves.
Most of what a capability set requires is expressed as maintaining a state machine, so that phrase needs pinning down first.
What 'implement a state machine' means
Implementing a state machine has two components:
- Track: maintain a local value for the machine, and update it as incoming messages report transitions.
- Drive: cause a transition that the participant's roles authorize, and announce it so the other participants learn of it.
The two are separate obligations. A participant that tracks but does not drive leaves the others to discover its state changes some other way. A participant that drives but does not track acts on case state it does not know. Which transitions a participant can drive depends on its roles (§13.4 Role-Specific Normative Requirements); every participant tracks.
Four dimensions, five state machines
Case State (CS) is a compound of two independent axes, so the protocol realizes four tracked dimensions as five state machines:
- VFD — Vendor Aware, Fix Ready, Fix Deployed. Participant-specific: it records what one participant has done (§8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed).
- PXA — Public Aware, Exploit Public, Attacks Observed. Participant-agnostic: it records the state of the world, and it is shared case state (§8.2 PXA — Public Aware, Exploit Public, Attacks Observed).
This specification says "four dimensions" when describing what is tracked and "five state machines" when describing what the protocol defines. Both counts are correct; they count different things.
The Vultron implementation splits VFD into two machines, so it has six.
A vendor path, CS_vf (vf, Vf, VF), holds Vendor Aware and Fix Ready.
A deployer path, CS_d (d, D), holds Fix Deployed.
The two paths combine into six pairs.
The VFD order of §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed rules out the two pairs with a deployed fix that was never ready, which leaves the same four VFD states (vfd, Vfd, VFd, VFD) and the same 32 compound CS states.
Case Observer capability set
The Case Observer capability set is the participation floor. Every actor that participates in a Vultron case provides it, because the Observer role is the base role and every other role adds to it.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-25-001 |
MUST | An Observer (OBSERVER) is a Tier-1 case participant: it MUST hold a CaseParticipant record, run the standard RM lifecycle, and satisfy the same embargo-consent gate (MV-10-005) as any other participant. OBSERVER is the base role — the lowest non-null privilege set in the Vultron protocol. All other CVD roles are additive to it.Defining Observer as a full participant (not a passive consumer or an external T0 actor) ensures it is subject to the same admission and embargo-consent rules as Vendors and Coordinators. The "base role" framing establishes OBSERVER as the correct fallback when no other role applies, rather than leaving CVDRole.OTHER as an unspecified catch-all. See ADR-0057. |
Uses definition from: MV-10-005 |
There is no sub-Observer participation level. An actor that accepts a case invitation has committed to Observer behavior from that point: it tracks state and reports its own transitions.
A Case Observer implementation maintains all five protocol state machines — RM, EM, PEC, VFD, PXA — for itself. It holds a current value for each, and it drives the transitions that its roles authorize.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-03-001 |
MUST | The system MUST implement the three interacting state machines: RM (Report Management), EM (Embargo Management), and CS (Case State) Report handling, embargo negotiation, and the public and fix state of a case change for different reasons and at different times. Three interacting machines let an implementation validate each one on its own. The interactions between them stay explicit and do not hide in one combined state. |
|
CM-03-002 |
MUST | RM state MUST be participant-specific Each participant moves through report handling on its own. One participant can accept a report that another has not yet validated. A single shared RM state cannot show this, and one participant's transition would overwrite the state of another (CM-01-002). |
|
CM-03-005 |
MUST | VFD (Vendor Fix Deployment) state MUST be participant-specific Fix readiness and deployment are different for each participant. One vendor can ship a fix before another vendor, and a deployer has its own deployment state. A shared VFD state would let the progress of one participant show as the progress of another (ADR-0075). |
|
CM-10-001 |
MUST | CaseParticipant MUST record its consent per embargo: one consent row for every entry in the case's embargo register, naming the embargo and the participant's answer to it, UNINVITED until it is asked (CM-18-001). A participant agrees to an embargo explicitly, by an Accept, as its proposer, by seeding (CM-14-003, CM-14-005), or by containment, when the Case Owner activates a revision that ends no later than terms the participant had agreed to (EP-05-001). Each invitation's RSVP deadline is stored on that invitation's INVITED row (CM-28-013). No other record of embargo consent may exist on the participant.Consent is per embargo (ADR-0093, ADR-0122), so a revision does not inherit an agreement given to an earlier version (CM-18-001). The CM-10-004 content gate reads the rows, so they must name every embargo that binds the participant, including one that containment carries over: an agreement to N days is an agreement to every shorter period, so no explicit Accept is needed for it. A second record of consent beside the rows can disagree with them, and a reader cannot know which is correct. |
Uses definition from: CM-18-001 See also: CM-14-003 — context for the reader See also: CM-14-005 — context for the reader See also: CM-28-013 — context for the reader See also: EP-05-001 — context for the reader |
It also tracks the states of the other participants in the case, to inform its own decisions. That is a recommendation rather than a requirement, because the protocol does not depend on any participant holding perfect information about the others.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
VP-01-001 |
SHOULD | Participants SHOULD track the state of other Participants in a case to inform their own decision making A participant's next move depends on where the others stand: whether a vendor has a fix, whether anyone has published, whether a coordinator has left. Without tracking their states a participant acts on a stale picture and may, for example, publish before a vendor is ready. |
|
VP-01-002 |
SHOULD | Participants SHOULD track the RM states of the other Participants in the case RM state says whether each participant is still engaged with the report. Knowing it tells a participant who will still act on the case, whose replies to expect, and when a vendor has stopped work. |
|
VP-01-003 |
MUST NOT | Correct operation of the protocol MUST NOT depend on perfect information across all Participants Participants in a distributed CVD case never all see the same state at the same moment: messages are delayed, lost, or withheld by embargo scope. A protocol that needed perfect shared information would stall or misbehave in every real case, so each step must be safe on the partial view a participant actually holds. |
When its own state changes, the protocol recommends that it send the message for the transition. When it is told of another participant's transition, it updates its local state.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
VP-03-012 |
SHOULD | Participants whose state changes in the RM, EM, or CVD Case State Models SHOULD send a message for each transition to the case's CASE_MANAGER, which fans it out to the other Participants (PCR-08-001, VP-18-002). Each participant decides from its picture of the others' states (VP-01-001). Announcing every RM, EM and CS transition keeps those pictures current; an unannounced transition, such as a fix becoming ready, leaves others acting on stale information. Participants never message each other directly, so the CASE_MANAGER's fan-out is how the transition reaches them. |
See also: PCR-08-001 — context for the reader See also: VP-18-002 — context for the reader |
CM-04-001 |
MUST | A receiver of a participant-status message MUST record the declared RM state on the sending actor's CaseParticipant, as its model of the sender (SM-10-001).RM state is self-declared: each participant reports its own report-handling progress (CM-03-002). A participant-status message updates the receiver's model of its sender. A record on any other participant would give one participant the progress of another. Other messages move the receiver's own state instead (SM-10-001). RSH-08-003 says which receiver writes the record directly. |
Refines: SM-10-001 Implements: VP-01-002 |
CM-04-002 |
MUST | A receiver processing a VFD state transition MUST update the VFD state in the participant status of the sending actor's CaseParticipantVFD state is participant-specific (CM-03-005). A VFD message reports the fix readiness or deployment of the sender. A record on any other participant would claim a fix that this participant did not make. |
Refines: SM-10-001 |
CM-04-004 |
MUST | When the CASE_MANAGER adopts a PXA transition (public disclosure, exploit publication or attack observation), it MUST record the case-level PXA state in the case's CaseStatus. Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003).PXA state is a case-level fact (CM-03-004). A record of a reported disclosure, exploit or attack on the shared CaseStatus makes it visible to all participants at the same time. This is important because each of these events can end an embargo early. Only the CASE_MANAGER writes canonical case state (ADR-0108). |
Refines: SM-10-002 See also: RSH-08-003 — context for the reader |
It takes part in embargo negotiation: it answers an Invite(EmbargoEvent) addressed to it, and the CASE_MANAGER records its consent or refusal in PEC (§9 Participant Embargo Consent (PEC) State Machine).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
EP-09-003 |
MUST NOT | A participant that receives an Invite(EmbargoEvent) MUST NOT write case EM state or any participant's consent state on receipt. It stores the Invite and answers it with Accept or Reject addressed to the CASE_MANAGER through its response decision (EMB-15).Only the CASE_MANAGER turns an announcement into case state and every other participant takes case state from the ledger (ADR-0108, RSH-08-003). Consent is recorded when the CASE_MANAGER commits the answer, and the replica learns it from the ledger. |
Refines: RSH-08-003 |
EP-09-025 |
MUST NOT | A participant MUST NOT treat an Add(CaseLedgerEntry) that carries a proposal or an Invite as an invitation to answer. A participant answers only an Invite addressed to it.The ledger is a channel for case state, not a protocol interaction. Giving an entry parse-and-respond semantics would let every future entry type become an implicit request, and would fork the negotiation into two paths, one over Invites and one over entries. The interactions the behavioural specs define are the ones that happen; the ledger records them. |
|
EMB-15-004 |
MUST | An actor that rejects an embargo overture MUST answer with the activity that matches what it rejects. The Case Owner deciding a proposal for the case sends ER, its Reject(EmbargoEvent)[target=VulnerabilityCase], which returns the shared EM to NONE (EMB-06, MSM-07-009). A participant answering an embargo Invite sends a Reject of the Invite, which records only its own consent (MSM-07-004). That Reject marks the rejected embargo's row DECLINED. A signatory refusing proposed terms keeps its row for the embargo in force (MSM-07-015).A proposal and an Invite carry different EM and consent semantics, so the rejection has to match the overture for every participant to read it the same way. The pre-public constraint (EMB-01-002) is a hard protocol rule that overrides any local acceptance policy. ECA DetailsPreconditions - Inbound overture received; decision resolves to reject, OR CS is public/exploit/attacks forcing rejection (EMB-01-002) Steps 1. [participant] Answer with the rejection that matches the overture → The Case Owner's decision on a proposal is ER (EM → NONE); an embargo Invite gets a Reject of the Invite, recording DECLINED Postconditions - Overture rejected with the activity that matches it |
Uses definition from: MSM-07-009 Uses definition from: MSM-07-004 See also: MSM-07-015 — context for the reader |
It sends every case-scoped message to the CASE_MANAGER (§10.2 Routing Topology).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
PCR-08-001 |
MUST | After a case is created and its CASE_MANAGER introduced, a participant MUST address each case-scoped message to that CASE_MANAGER alone, never directly to another participant. Case-scoped messages include notes, status updates, embargo proposals, RM transitions and any other protocol message about the case. The one exception is RK, Read(Offer(VulnerabilityReport)). RK answers the reporter's original Offer outside the case. So an addressee of that Offer sends RK to the reporter, never to the CASE_MANAGER (RMB-08-003, RMB-08-005).A participant sends each case-scoped message to the CASE_MANAGER, so that the CASE_MANAGER can check the sender, record the change in the case ledger and send it on to the other participants (PCR-08-003). A message sent straight to a peer gets none of these steps, so the peer's replica and the canonical case disagree. RK is not a case message: it answers the reporter's Offer, which the reporter sent to that receiver before the case existed, so the answer goes back to the reporter (RMB-08-003). |
See also: RMB-08-005 — context for the reader |
PCR-08-005 |
MUST | A participant MUST take the sole to: recipient of a case-scoped message from its case replica. That recipient is the participant holding the CASE_MANAGER role, never the case's full participant list.The case's full participant list includes actors that are not entitled to every message (CM-10-004), and it reaches peers that the CASE_MANAGER has not yet checked the message for. Taking the CASE_MANAGER from the participant's own replica gives one recipient that the participant already trusts. |
It can report PXA observations (§13.4.2 Participant-Agnostic CS Transitions (PXA)). It has no VFD drive obligations unless one of its roles adds them.
Why there is no sub-Observer level
A monitoring-only actor might seem to need message parsing and nothing else. Two things rule that out. An actor that does not track its own PEC state cannot take part in embargo negotiation, and the CASE_MANAGER decides what to send it on the basis of that state — so an untracked participant cannot be reliably served. An actor that does not track RM has no basis for evaluating case status. Meaningful use of Vultron data requires the full Observer set.
The protocol governs what the CASE_MANAGER sends, not what a recipient does with information it already holds. Vultron gates dissemination; it cannot constrain display.
A parse-only tool is not a case Participant: it holds no CaseParticipant record and no case is obliged to deliver anything to it.
Role-specific drive obligations
All Observer participants track all five machines. Which transitions a participant drives depends on its role extension set: a Vendor drives its own fix-ready transition, a Deployer drives its own fix-deployed transition, and any participant can report PXA observations. See §13.3 Role Taxonomy and §13.4 Role-Specific Normative Requirements.
Case Decision capability set
The Case Decision capability set provides what the Case Owner role needs. It is separable from the Case Hosting capability set. It adds these to the Case Observer capability set:
- The Case Owner's own status reports are adopted without an approval step, because its updates are authoritative (§11.3 Status Adoption: One Authorization Gate).
- The Case Owner decides the shared embargo: it activates and rejects embargo proposals for the case, and terminates the embargo in force.
- The Case Owner can transfer case ownership, by a proposal to the CASE_MANAGER (§12.3 Case Ownership Transfer).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-02-005 |
MUST | CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism). These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case. |
See also: CM-02-006 — context for the reader |
MSM-07-008 |
MUST | The wire activity ACTIVATE_EMBARGO_ON_CASE (wire form: Add(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST activate the named proposal's embargo register entry and supersede any entry in force in the same step. The derived EM becomes ACTIVE (EA, or EC for a revision). Giving the owner's decision its own activity retires the two-audience rule: an Accept of an Invite is always the sender's consent (MSM-07-003), and this activity is always the owner's decision for the case, so neither meaning depends on who sent the message (ADR-0122). The activity is an Add because the case gains the embargo, as the Remove that ends it takes it away, so the decision and a consent differ by verb (ADR-0180). When it replaces an embargo in force, the MSM-07-005 consent rule settles the rows. |
Uses definition from: VAM-05-008 |
MSM-07-009 |
MUST | The wire activity REJECT_EMBARGO_PROPOSAL_ON_CASE (wire form: Reject(EmbargoEvent)[target=VulnerabilityCase], the EmbargoEvent itself as the object, inReplyTo naming the Invite(EmbargoEvent) that proposed it) is the Case Owner's decision for the case. It MUST reject the named proposal's embargo register entry. Once no other proposal is open, the derived EM becomes NONE (ER) or stays ACTIVE with the prior terms in force (EJ). It stays PROPOSED or REVISE while another proposal is open (EMB-18-005). The owner's rejection decides the proposal for the case; whether the owner, as a participant, also refuses those terms is a separate Reject of the Invite (MSM-07-004). The owner's own row does not constrain the rejection: an owner that accepted terms for itself may still reject them for the case (ADR-0180). Keeping the two apart lets the owner keep the prior terms without declining them (ADR-0122). |
Uses definition from: VAM-05-009 Uses definition from: EMB-18-005 |
CM-21-005 |
MUST | A Case Owner MUST propose an ownership transfer by sending Offer(Offer(VulnerabilityCase)), with the case as context, to the CASE_MANAGER only, never to the transferee (PCR-08-001).Routing the transfer through the CASE_MANAGER lets it ledger the offer in flight and broadcast it to every active participant (CM-10-004), so no participant is unaware a transfer is being negotiated. The CASE_MANAGER cannot be the transferee: its Offer would have itself as its only recipient, which BT-17-008 forbids, the same ground on which CM-33-003 refuses a role offer to it. |
Refines: PCR-08-001 |
CM-21-025 |
MUST | The inner Offer of an ownership-transfer proposal MUST name the case as its object and the transferee as its target. It optionally carries the deadline to answer as its end_time (CM-21-016).The inner Offer says what the owner asks the CASE_MANAGER to offer and to whom. Without the case and the transferee in it, the CASE_MANAGER cannot make the Offer the owner asked for (CM-21-028). |
Extends: CM-21-005 Uses definition from: CM-21-016 |
CM-21-026 |
MUST | The CASE_MANAGER MUST refuse an ownership-transfer proposal, with no ledger commit and no outbound Offer, unless its inner Offer passes two checks. The inner Offer's object is the proposal's case. Its target is an actor the CASE_MANAGER can address (present, neither itself nor the proposer) and an active participant of the case (CM-21-021).A proposal is a request the CASE_MANAGER acts on. An inner Offer that names another case, or a transferee the CASE_MANAGER cannot address, would make an Offer nobody can answer, or one about a case the proposal did not concern. |
Extends: CM-21-005 Uses definition from: CM-21-021 |
CM-21-027 |
MUST | When it admits an ownership-transfer proposal, the CASE_MANAGER MUST ignore any id, actor or to inside the inner Offer.The CASE_MANAGER makes the Offer itself (CM-21-028). An id, actor or recipient list that the owner wrote into the inner Offer would let the owner choose fields that only the CASE_MANAGER sets, such as an id that collides with a stored object. |
Extends: CM-21-005 |
CM-21-028 |
MUST | On admitting a proposal, the CASE_MANAGER MUST make the single ownership-transfer Offer(VulnerabilityCase) itself, under an id it derives from the proposal, addressed to the transferee. The Offer's actor is the CASE_MANAGER, its attributed_to the owner and its in_reply_to the proposal (CM-24-001, CM-24-002, CM-24-020).Making the Offer itself rather than forwarding the owner's gives a transfer one Offer, under an id no other party chose, told apart from the proposal by its shape (ADR-0148, DL-06-006). |
Extends: CM-21-005 Refines: CM-24-001 Refines: CM-24-002 Refines: CM-24-020 |
CM-21-029 |
MUST | The CASE_MANAGER MUST ledger the Offer it made from a proposal once that Offer is in its outbox (SYNC-09-002). That Offer is the one that is ledgered, answered, closed and expired. Ledgering the Offer after it is queued keeps the ledger from recording an Offer that was never sent. One ledgered Offer gives every reader one transfer to answer, close or expire (CM-21-014). |
Extends: CM-21-028 Refines: SYNC-09-002 |
MSM-07-028 |
MUST | ACTIVATE_EMBARGO_ON_CASE MUST mark the Case Owner's row for the activated embargo AGREED when that row is UNINVITED, INVITED or TIMED_OUT. An AGREED row is left as it is, and an activation from a DECLINED row is refused (MSM-07-037). The owner that activates terms is bound by them, so its own row has to say so. A row that holds no answer the owner gave, or only a lapsed invitation, contradicts nothing when it becomes AGREED, so the owner need not accept before it activates (ADR-0180). |
Extends: MSM-07-008 Uses definition from: CM-18-003 |
MSM-07-029 |
MUST | The CASE_MANAGER MUST refuse ACTIVATE_EMBARGO_ON_CASE before committing it in two cases. One is a named embargo that is not an open proposal of the case. The other is CS that is public, exploited or attacked (EMB-02-002). Refusing a doomed activation before the commit keeps the ledger free of an entry that replicas, copying its step, would apply without the CASE_MANAGER's P/X/A check (CM-23-016). |
Extends: MSM-07-008 Refines: EMB-02-002 |
MSM-07-027 |
MUST | The CASE_MANAGER MUST accept ACTIVATE_EMBARGO_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006). Activating an embargo is the Case Owner's decision for the case (CM-02-005), so no other participant's activity may make it. |
Extends: MSM-07-008 Refines: HP-01-006 |
MSM-07-031 |
MUST NOT | REJECT_EMBARGO_PROPOSAL_ON_CASE MUST NOT change any participant's consent rows, the Case Owner's included. The owner's decision for the case is not its consent as a participant; that is a Reject of the Invite (MSM-07-004). |
Extends: MSM-07-009 |
MSM-07-032 |
MUST | This rule covers REJECT_EMBARGO_PROPOSAL_ON_CASE of the last open revision while CS is public, exploited or attacked. The CASE_MANAGER MUST also terminate the embargo in the same act (EMB-04-002). It trial-applies both steps before committing either. It commits the Reject's entry carrying the REJECT step, then its own ET Remove(EmbargoEvent) entry carrying the TERMINATE step. A refused termination commits neither.Reverting to the prior terms is not viable once disclosure has happened, so the rejection ends the embargo. Deciding both steps together means a replica copying both entries ends with the revision REJECTED and EM EXITED, as the CASE_MANAGER does. |
Extends: MSM-07-009 Refines: EMB-04-002 |
MSM-07-033 |
MUST | The CASE_MANAGER MUST refuse REJECT_EMBARGO_PROPOSAL_ON_CASE before committing it when the named embargo is not an open proposal of the case. There is nothing to decide, and a committed entry naming no open proposal would be applied by every replica that copies it. |
Extends: MSM-07-009 |
MSM-07-030 |
MUST | The CASE_MANAGER MUST accept REJECT_EMBARGO_PROPOSAL_ON_CASE only from the Case Owner. It refuses any other sender with REFUSED before any write (HP-01-006). Deciding a proposal for the case is the Case Owner's authority, so no other participant's activity may reject it for the case. |
Extends: MSM-07-009 Refines: HP-01-006 |
A human Coordinator typically provides the Case Decision capability set while a service actor provides Case Hosting.
Case Hosting capability set
The Case Hosting capability set provides what the CASE_MANAGER role needs. It is separable from the Case Decision capability set. It adds the following to the Case Observer capability set.
It holds the CASE_MANAGER role for each case it hosts, and so it is that case's single writer (§10.1 Single-Writer Authority).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-02-001 |
MUST | Each VulnerabilityCase MUST have exactly one associated CASE_MANAGER The CASE_MANAGER is the only writer of canonical case state (CM-02-002). With no CASE_MANAGER, no actor can commit a case change. With two, two actors can commit changes that conflict. The copies of the case then become different, and no rule can make them agree again. |
|
CM-02-002 |
MUST | CASE_MANAGER MUST be the authoritative source of truth for case state Every participant has its own copy of the case. Without one source of authority, two participants that disagree have no rule to decide which copy is correct, and the copies become different. When the CASE_MANAGER is that source, every replica gets the same state (ADR-0108). |
|
BT-10-003 |
MUST | The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids. |
Depends on: BT-10-002 |
BT-10-004 |
MUST | The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them. |
It keeps the canonical case ledger, and replicates each entry to the participants as Add(CaseLedgerEntry).
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CLP-04-001 |
MUST | The authoritative history of a case MUST be the append-only canonical ledger; every entry in it records a protocol-significant admitted assertion. The ledger contains no refused or locally-scoped entries (see CLP-04-007). Replicas agree only when they share one source of history. If any other record could also define the case history, two holders could each follow a different source and disagree with no way to decide which is correct. |
See also: CLP-04-007 — context for the reader |
CLP-04-004 |
MUST | CASE_MANAGER fan-out replication MUST deliver the canonical CaseLedgerEntry content, wrapped in an ActivityStreams transport envelope such as AddA replica must check the entry hash against the content that the CASE_MANAGER committed. If fan-out sends a rebuilt or summarized form, the replica cannot verify the chain. The envelope only carries the entry, so the entry stays the same for every recipient. |
|
PCR-08-003 |
MUST | The CASE_MANAGER MUST, for every participant message it receives and accepts, commit a CaseLedgerEntry recording the outcome and broadcast Add(CaseLedgerEntry) to the case's active participants (CM-10-004) as the standard cascade. This cascade is the only mechanism by which participants learn of accepted case-state changes.Participants learn of case changes only from the ledger. If the CASE_MANAGER applied a change without an entry, or recorded an entry without sending it, the other replicas would never learn of the change and would disagree with the canonical case. |
Uses definition from: CM-10-004 |
It runs multi-party case management: participant invitation and acceptance, role assignment and case ownership operations, each under the case's authorization rules.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-02-006 |
MUST | CASE_MANAGER MUST enforce case-level authorization for all case mutations The CASE_MANAGER applies every change to canonical case state. Thus it is the one place that can stop an unauthorized change before every replica copies it. If a change path skips the check, any actor that can get to the inbox can change the case. |
|
PCR-08-008 |
MUST | The invitee's Accept of that Invite (PCR-08-007) MUST be addressed to the CASE_MANAGER (not the Case Owner). The CASE_MANAGER is the authoritative recipient and processor of all case-management handshake messages after case creation.Only the CASE_MANAGER records the invitee's join in the case and in the ledger. When the Case Owner is not the CASE_MANAGER, an Accept addressed to the Case Owner reaches an actor that cannot record the join, so the join is never recorded. |
Refines: PCR-08-001 Uses definition from: PCR-08-007 |
PCR-08-009 |
MUST | The CASE_MANAGER MUST process an invitee's replies and record their effect on its own copy of the case: a reply to the stub Invite as CM-11-001 and CM-11-007 require, and a reply to the full-case Invite as CM-11-011 requires. The invitee's replies are the only source of its join and its judgment of the case. If the CASE_MANAGER did not record them, the case would show the invitee as not joined, and the invitee would get no case content. |
Uses definition from: CM-11-001 Uses definition from: CM-11-007 Uses definition from: CM-11-011 |
It applies the status adoption model, including the canonical-write-before-side-effects ordering (§11.3 Status Adoption: One Authorization Gate).
It delivers full case content only to a participant that passes the gate of §9.7 Gating Full Case Delivery.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-10-004 |
MUST | The CASE_MANAGER MUST share case content only with active participants, never with an inert one. A participant is active when three conditions hold. First, the case initialization sequence seated it (CM-14-001: the Case Owner, the CASE_MANAGER and the reporter), or it accepted the stub Invite (Accept(Invite(VulnerabilityCase preview)[target=Actor])). Second, it has not been removed (CM-31-001). Third, while an embargo is active, its consent row for that embargo is AGREED (CM-18-001). Every other participant is inert. Case content includes CaseLedgerEntry announcements, Announce(VulnerabilityCase), status broadcasts and embargo announcements (ADR-0114).Many cases have no active embargo: the embargo is not yet established, or it has already ended. Thus, "has accepted the active embargo" cannot be the only entitlement test. The stub Invite creates the participant record (ADR-0114), and a removed participant keeps its record (ADR-0116). Thus, the roster holds actors that have no entitlement. A sender must check entitlement, because membership does not show it. While an embargo is active, the AGREED row of the participant for that embargo is its agreement to protect what it receives (ADR-0122). |
Uses definition from: CM-14-001 Uses definition from: CM-18-001 Uses definition from: CM-31-001 |
CM-10-005 |
MUST NOT | This rule covers each Add(CaseLedgerEntry) the CASE_MANAGER sends, as fan-out of a new entry or as a replay answering a Reject(CaseLedgerEntry) (SYNC-03-002). While an embargo is active, the CASE_MANAGER MUST NOT send one to a participant that has not accepted that embargo (the CM-10-004 content gate).The ledger fan-out is how participants learn every accepted case change, and each entry carries its payload verbatim — an added report or note reaches the recipient whole. Fan-out is therefore "sharing case updates" in CM-10-004's sense. An entry cannot be redacted per recipient without breaking the hash chain. Skipping a single entry does not work either: the replica buffers the next one as a forward gap and Rejects to request the missing entry (SYNC-14-002), so the replay would deliver the withheld content anyway. The gate therefore pauses the participant's whole stream, replay included, rather than filtering entries; the replica stays at the last entry it was sent. |
Refines: CM-10-004 Uses definition from: SYNC-03-002 |
CM-10-008 |
MUST | While an embargo is active, the CASE_MANAGER MUST still deliver an embargo Invite, and its responses, to a participant that has not accepted the embargo. These are embargo meta-protocol activities addressed to the participant directly, not ledger fan-out.These activities are not ledger fan-out, so the CM-10-005 pause does not cover them. A participant that never receives the embargo Invite cannot accept the embargo, so its paused stream could never resume. |
Extends: CM-10-005 |
Ledger replication mechanics are specified separately
This specification states what the ledger is and that the CASE_MANAGER replicates it. One CASE_MANAGER holds exclusive write authority, and sends each entry to every participant actor.
The mechanics of that replication — hash-chaining, gap detection and ordering guarantees — are specified in a companion Vultron Ledger Replication Specification, which is still in draft and is not yet published alongside this document. An implementation cannot demonstrate conformance to the replication mechanics from this document alone. The reasoning for splitting them is recorded in ADR-0077.
Distributed consensus among several CASE_MANAGERs is a possible future extension and is out of scope here.
Named configurations
Common combinations of capability sets have names because they appear frequently in real deployments. These names are informative; conformance claims use the full capability set list.
| Configuration | Capability sets | Roles |
|---|---|---|
| Hosting Coordinator | Case Observer + Case Decision + Case Hosting | Coordinator + Case Owner |
| Self-coordinating Vendor | Case Observer + Case Decision + Case Hosting | Vendor + Deployer + Case Owner |
| Bug Bounty Platform | Case Observer + Case Hosting | CASE_MANAGER (Case Decision optional) |
A Hosting Coordinator is a type:service actor that holds both CASE_OWNER and CASE_MANAGER roles.
It decides and executes without a separate human approval step for its own status updates.
13.3 Role Taxonomy
13.3.1 Process Roles
Process roles define what an actor does within a case and which protocol transitions it is authorized to drive. An actor can hold several process roles, and what it may do is the union of what its roles permit.
| Role | Protocol capability |
|---|---|
| Reporter | Initiates cases; drives RS; authoritative source of the original report |
| Vendor | Drives its own VFD transition f→F (fix ready, CF) |
| Deployer | Drives its own VFD transition d→D (fix deployed, CD) |
| Coordinator | Coordinates multi-party disclosure; holds no independent protocol authority. Participant management is a CASE_MANAGER and Case Owner function |
| CVE Numbering Authority (CNA) | Can assign CVE IDs directly; a participant without the role delegates assignment. Orthogonal to the other roles, and typically co-held with Coordinator or Vendor |
| Observer | Holds no drive obligations for VFD; can report PXA observations (§13.4.2 Participant-Agnostic CS Transitions (PXA)) |
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-26-001 |
MUST | Each actor MUST judge a participant's permitted and obligated actions by the union of what its case roles permit. A MUST NOT attached to one role gives way when another of its case_roles carries a MAY, SHOULD or MUST for the same action class.CVD roles represent orthogonal functions a participant may perform. When a participant holds more than one function (e.g., a security researcher who is also a Deployer for an affected product), restricting them based on their least-capable role would incorrectly limit their protocol participation. The union model prevents role restrictions from blocking obligations that exist under a co-role. |
|
CSB-15-001 |
MUST | A participant MUST hold the VENDOR role in the case to report its own fix-ready transition (f → F). Fix readiness (F event) represents that the actor has produced a fix. Only actors who develop or maintain the affected product (Vendors) can produce a fix; Deployers operate existing deployments and do not produce fixes. Finders, Reporters, and Coordinators likewise MUST NOT self-report fix readiness. ECA DetailsPreconditions - A participant is about to report its own f → F transition Steps 1. [participant] Check that the participant holds the VENDOR role in the case → The check passes for a Vendor; the transition is refused otherwise 2. [participant] If the check passes, report its vf state as F → The report goes to the CASE_MANAGER Postconditions - Only a VENDOR participant reports F |
|
CSB-15-007 |
MUST NOT | A participant without the VENDOR role in the case MUST NOT record its own fix-ready transition (f → F). Such a participant has no vendor-fix (vf) path. Only a Vendor can produce a fix (CSB-15-001). A recorded F from any other participant would claim a fix it cannot have produced, and every reader of its status would believe it. ECA DetailsPostconditions - Only a VENDOR participant records F |
Extends: CSB-15-001 |
CSB-15-002 |
MUST | A participant MUST hold the DEPLOYER role in the case to report its own fix-deployed transition (d → D). Fix deployment (D event) represents applying a fix in one's own environment. Only actors who are responsible for operating deployed instances (Deployers) can perform this action. A shipping-product Vendor who does not control downstream deployment holds only the VENDOR role, not DEPLOYER, and has no deployer path. ECA DetailsPreconditions - A participant is about to report its own d → D transition Steps 1. [participant] Check that the participant holds the DEPLOYER role in the case → The check passes for a Deployer; the transition is refused for a VENDOR-only or any other non-DEPLOYER participant 2. [participant] If the check passes, report its d state as D → The report goes to the CASE_MANAGER Postconditions - Only a DEPLOYER participant reports D |
|
CSB-15-009 |
MUST NOT | A participant without the DEPLOYER role in the case MUST NOT record its own fix-deployed transition (d → D). Such a participant has no deployer (d) path. Only a Deployer operates the deployed instances (CSB-15-002). A recorded D from any other participant would claim a deployment it cannot have done. ECA DetailsPostconditions - Only a DEPLOYER participant records D |
Extends: CSB-15-002 |
CM-25-005 |
MUST NOT | A participant whose only case role is OBSERVER MUST NOT emit VFD state-transition messages (CV, CF, or CD). An Observer has no vendor-fix-deployment obligations and no authority to advance the VFD dimension on behalf of a product or service. An Observer joined the case to monitor it, not to own a fix path. Permitting VFD emissions from a role with no fix obligations would corrupt the VFD state machine for the case (e.g., a monitoring actor falsely claiming fix deployment). |
Capability prerequisites. Every case Participant, whatever its roles, provides the Case Observer capability set (§13.2 Capability Sets, §13.3.3 Roles and Capability Sets Are Independent). Role extension sets add obligations on top of that floor; they do not substitute for it. An implementation can check that an actor has the capability prerequisites for a role before it completes a role assignment (§12.1 Role Assignment).
This specification states the per-role obligations in §13.4 Role-Specific Normative Requirements. It does not yet state a complete capability prerequisite for every role.
Note on Reporter
Reporters are most often also the discoverer of the vulnerability, but the protocol is concerned with who reported it, not who found it. The identity of the original discoverer can be recorded in the report itself or in case Notes, but nothing in the technical protocol hinges on that distinction. Reporter is the protocol-salient role from first contact.
13.3.2 Protocol Coordination Roles (protocol authority)
These roles confer specific protocol-layer authority and are distinct from process roles. They describe what an actor controls within the protocol machinery, not what it does in the world.
| Role | Protocol authority |
|---|---|
| Case Owner | Authoritative decision-maker for a case; status updates are treated as authoritative without requiring approval; drives shared EM transitions |
| CASE_MANAGER | Holds the case's single-writer authority (§10.1 Single-Writer Authority): writes the canonical case ledger, relays case-scoped messages, and manages the roster on the Case Owner's behalf (§2.2 Roles). Authority follows the role, not the actor that holds it; the role is commonly co-held with Coordinator but need not be (§13.3.3 Roles and Capability Sets Are Independent) |
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-21-001 |
MUST | A VulnerabilityCase MUST have at most one participant that holds CASE_OWNER at any point in time.CASE_OWNER confers exclusive case administration authority (CM-02-004, CM-02-005). Two simultaneous holders would create conflicting authority: both could terminate embargoes, authorise invitations, and mutate case state independently. The invariant must be enforced at the data-layer level, not just assumed by convention. |
|
CM-21-023 |
MUST | When a new owner is designated, the system MUST remove CASE_OWNER from the previous holder before, or atomically with, granting it to the new owner.A grant made before the strip would leave two holders for a moment, which CM-21-001 forbids. Stripping first, or in the same step, keeps the invariant at every point in time. |
Implements: CM-21-001 |
CM-02-004 |
MUST | CASE_MANAGER MUST know the Case Owner Only the Case Owner can do some case actions (CM-02-005). The CASE_MANAGER can enforce this only if it knows the Case Owner. The case records the Case Owner in attributed_to. |
|
CM-02-005 |
MUST | CASE_MANAGER MUST restrict the following activities to the Case Owner: case closure, approving an embargo proposal to become active on the case and terminating an active embargo, approving or rejecting participant invitations, case ownership transfer, and offering a participant an additional role (CM-33-002) (see CM-02-006 for the authorisation mechanism). These actions decide who learns about the vulnerability, under what embargo, and who is responsible for the case. In CVD, the Case Owner makes these decisions. If any participant can start them through the CASE_MANAGER, a participant can close the case, change the embargo, admit a party that nobody checked, or take the case. |
See also: CM-02-006 — context for the reader |
Delegation scenarios: Protocol responsibilities can transfer during a case lifecycle. For example, a Reporter who initially creates a case can delegate coordination to a Coordinator (reporter → coordinator hand-off), or a primary Vendor can bring in additional Vendors as the case grows. When a Case Owner transfers ownership, through a proposal to the CASE_MANAGER that the transferee accepts (§12.3 Case Ownership Transfer), the receiving actor acquires Case Owner authority and the associated protocol responsibilities.
Open architectural question: key handover
Moving the CASE_MANAGER role to a different actor raises an unresolved key-handover question for future case-encryption designs.
The question is stated once, at §12.3 Case Ownership Transfer.
13.3.3 Roles and Capability Sets Are Independent
A role is a position within a case. A capability set is a property of software. Mixing them produces contradictions, so the relationship is stated explicitly:
- Every case Participant, whatever its roles, provides the Case Observer capability set (§13.2 Capability Sets).
Holding a role means having a
CaseParticipantrecord, an RM state, and therefore tracking obligations. - A parse-only actor is not a case Participant: it holds no role and no case owes it delivery.
- An implementation holding the Case Hosting capability set additionally hosts the CASE_MANAGER role and is obliged to run the ledger. Case Hosting is commonly co-held with the Coordinator role. Ledger authority follows the CASE_MANAGER role the implementation holds — not its hosting location, and not any actor name.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
BT-10-002 |
MUST | Case creation MUST establish the case's CASE_MANAGER by recording a participant that holds the CASE_MANAGER role.The CASE_MANAGER is a role that a participant holds. It is not a separate entity. When case creation records the role on a participant, any actor can take the role, and every participant finds the CASE_MANAGER in the participant records of the case. |
|
BT-10-003 |
MUST | The actor holding the CASE_MANAGER role for a case MUST process that case's messages. The authority is that role, not any particular actor that enacts it.When message processing follows the role and not one specific object, any actor that holds the role can do the work. This includes an actor that the Case Owner delegates the role to, and the Case Owner itself. If an obligation names a separate case actor, implementations create one for each case, which BT-10-002 forbids. |
Depends on: BT-10-002 |
BT-10-004 |
MUST | The actor holding the CASE_MANAGER role for a case MUST enforce that case's authorization decisions.Each authorization decision of a case needs one enforcer that every participant can name. The CASE_MANAGER processes the messages of the case (BT-10-003), so it is the actor that admits or refuses them. |
Observer is a participant role, not a passive state
An Observer role holder that is in a case implements the full Case Observer capability set: it has an RM state, it is subject to embargo consent, and it can report PXA observations. The Observer role is distinguished by holding no VFD drive obligations — not by being exempt from state tracking.
Observer role admission follows the standard Invite / Accept(Invite) path.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-25-002 |
MUST | An Observer MUST be admitted to a case via the standard Invite/Accept flow defined in CM-17.Requiring a non-empty case_roles value is load-bearing: the participant record created with the stub Invite (CM-11-026) carries the roles that Invite names. A missing or empty list would create an Observer participant with no role — indistinguishable from a defect. |
|
CM-25-006 |
MUST | The Invite activity sent by the CASE_MANAGER for an Observer MUST carry case_roles naming OBSERVER only.The stub Invite creates the participant record and gives it the roles that the Invite names (CM-11-006). An Invite without CVDRole.OBSERVER would create a participant with an empty role list. Role checks cannot tell that record from a record that lost its roles. An Invite that names other roles would give the Observer obligations or authority that it was not invited to hold. |
Extends: CM-25-002 Refines: CM-17-003 |
13.4 Role-Specific Normative Requirements
13.4.1 Participant-Specific CS Transitions (VFD)
VFD records what a specific participant has done, so authority to cause a VFD transition is scoped to the participant that did it.
Recall: vendor/fix/deploy states
| State | Vendor Aware | Fix Ready | Fix Deployed |
|---|---|---|---|
vfd |
no | no | no |
Vfd |
yes | no | no |
VFd |
yes | yes | no |
VFD |
yes | yes | yes |
Full definitions are in §8.1 VFD — Vendor Aware, Fix Ready, Fix Deployed.
Participant status is self-declared: each participant reports its own VFD transitions. Each self-reported transition needs the role that owns it:
f→F(VFd, fix ready) needs the Vendor role.d→D(VFD, fix deployed) needs the Deployer role. A Deployer that is not also a Vendor has no fix of its own, so it can deploy only once some Vendor in the case has a fix ready.
A Vendor-only actor therefore cannot advance past VFd.
A CASE_MANAGER refuses a received status that states a fix-readiness value from a sender without the Vendor role, or a deployment value from a sender without the Deployer role.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
PRM-06-001 |
MUST | Participant status is self-declaratory by default: each participant asserts its own RM and VFD state without external approval. This is why they are participant status items (ADR-0121). The one write about a participant that the participant does not make is its birth: the CASE_MANAGER creates the record at RM RECEIVED (and VF vf for a vendor) when it sends the stub Invite (CM-11-006, ADR-0114).The self-declaratory model keeps state authority with the role holder. Deviations must be narrow, externally evidenced, and explicitly named (ADR-0121). |
See also: CM-11-006 — context for the reader |
CSB-15-001 |
MUST | A participant MUST hold the VENDOR role in the case to report its own fix-ready transition (f → F). Fix readiness (F event) represents that the actor has produced a fix. Only actors who develop or maintain the affected product (Vendors) can produce a fix; Deployers operate existing deployments and do not produce fixes. Finders, Reporters, and Coordinators likewise MUST NOT self-report fix readiness. ECA DetailsPreconditions - A participant is about to report its own f → F transition Steps 1. [participant] Check that the participant holds the VENDOR role in the case → The check passes for a Vendor; the transition is refused otherwise 2. [participant] If the check passes, report its vf state as F → The report goes to the CASE_MANAGER Postconditions - Only a VENDOR participant reports F |
|
CSB-15-007 |
MUST NOT | A participant without the VENDOR role in the case MUST NOT record its own fix-ready transition (f → F). Such a participant has no vendor-fix (vf) path. Only a Vendor can produce a fix (CSB-15-001). A recorded F from any other participant would claim a fix it cannot have produced, and every reader of its status would believe it. ECA DetailsPostconditions - Only a VENDOR participant records F |
Extends: CSB-15-001 |
CSB-15-002 |
MUST | A participant MUST hold the DEPLOYER role in the case to report its own fix-deployed transition (d → D). Fix deployment (D event) represents applying a fix in one's own environment. Only actors who are responsible for operating deployed instances (Deployers) can perform this action. A shipping-product Vendor who does not control downstream deployment holds only the VENDOR role, not DEPLOYER, and has no deployer path. ECA DetailsPreconditions - A participant is about to report its own d → D transition Steps 1. [participant] Check that the participant holds the DEPLOYER role in the case → The check passes for a Deployer; the transition is refused for a VENDOR-only or any other non-DEPLOYER participant 2. [participant] If the check passes, report its d state as D → The report goes to the CASE_MANAGER Postconditions - Only a DEPLOYER participant reports D |
|
CSB-15-009 |
MUST NOT | A participant without the DEPLOYER role in the case MUST NOT record its own fix-deployed transition (d → D). Such a participant has no deployer (d) path. Only a Deployer operates the deployed instances (CSB-15-002). A recorded D from any other participant would claim a deployment it cannot have done. ECA DetailsPostconditions - Only a DEPLOYER participant records D |
Extends: CSB-15-002 |
CSB-15-004 |
MUST | A participant that holds the DEPLOYER role but not the VENDOR role MUST be permitted to make the d→D transition only when at least one participant holding the VENDOR role in the same case has reached F (fix ready). Such a participant has no vendor-fix (VF) state of its own and is at d before the transition; the transition moves it to D, recording deployment of a fix another participant produced. A participant with the DEPLOYER role and no VENDOR role has a deployer path and no vendor path (ADR-0075). It can deploy only a fix that exists, so its d→D move waits until at least one VENDOR participant in the case is at F. Its d dimension starts at d and moves to D when that gate passes. The gate asks only that some VENDOR is at F, because the protocol does not record which vendor a deployer depends on, and a rule that named the vendor would need that record. ECA DetailsPreconditions - The participant holds the DEPLOYER role but not VENDOR in the case (no vendor path; deployer path at d); at least one other participant holds the VENDOR role and is at F Steps 1. [participant] Check that the participant holds DEPLOYER and not VENDOR, and that at least one participant in the case holds VENDOR and is at F (causal gate) → All checks pass; d → D transition allowed 2. [participant] Record its d state as D and report it → d is D (it was d); the participant still has no vendor path; the report goes to the CASE_MANAGER Postconditions - The DEPLOYER-only participant records D with no vendor path throughout; at least one VENDOR participant is at F in the same case |
Extends: CSB-15-002 — CSB-15-002 gates d→D on the DEPLOYER role; CSB-15-004 adds the causal precondition requiring at least one VENDOR participant to be at F first |
RSH-09-003 |
MUST | A received ParticipantStatus MUST be refused when any of these holds: the participant's recorded RM state is CLOSED, which is terminal; its RM state moves backwards (RSH-06-002); it states a fix-readiness value but the sender does not hold the VENDOR role, or a deployment value but the sender does not hold the DEPLOYER role; a stated fix-readiness, deployment or public-state (P/X/A) value is neither the participant's most recent recorded value nor a forward move from it. A dimension the sender omits is not refused, and does not reset the recorded value a later status is judged against. Every status states an RM state: one that leaves rmState out states the initial START. The embargo state the status embeds is not judged against the case: the case derives EM from its embargo register.Each rule refuses a claim no sequence of events could produce from the participant's recorded state. A non-adjacent forward move is accepted (RSH-06-001, CSB-16-001): a peer may have advanced several steps between messages. EM belongs to the embargo register (ADR-0122), and the report's P/X/A reaches the case only through the adoption gate (RSH-01-003). |
Extends: RSH-09-001 |
Two transitions can also be asserted on another participant's behalf, by the CASE_MANAGER or the Case Owner.
Vendor awareness (v→V) is the usual case: the party that notified the vendor knows that the vendor has the information.
The protocol expects evidence of the notification to ground the assertion — for example, the vendor's acknowledgment of its Invite.
The reference implementation does not check this evidence.
It checks only that the asserter holds the CASE_MANAGER or Case Owner role and that the target is already a participant holding the Vendor or Deployer role.
A Deployer's fix deployment (d→D) can be asserted the same way, which is expected to be rare: deployment is normally the Deployer's own report.
Fix readiness is never asserted on a vendor's behalf, because only the vendor can know it.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
PRM-06-003 |
MAY | A CASE_MANAGER or Case Owner MAY assert v→V (Vf) on behalf of a Vendor-role participant when the notification or invite is evidenced. Any vendor acknowledgement, including Read(Invite(VulnerabilityCase preview)[target=Actor]), is evidence. The target is typically an inert invitee that has not yet replied, and it must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the d→D of PRM-06-004.Without this path, the case cannot record that an invited vendor is aware until the vendor replies to the Invite. A vendor acknowledgement already shows that the vendor is aware. The stub Invite creates the record (ADR-0114), so the assertion has a target. RM stays the same, so the assertion does not speak for the report decisions of the vendor. The pair with d→D is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it. |
|
PRM-06-007 |
MUST NOT | An on-behalf v→V write by a CASE_MANAGER or Case Owner MUST NOT change the target's RM state (ADR-0121).RM records the vendor's own report decisions. The on-behalf assertion speaks only for the vendor's awareness, which its acknowledgement shows, so it leaves RM where the vendor put it. This holds for an inert invitee written before it replies (CM-11-029): awareness of the case is not a decision about it. |
Extends: PRM-06-003 |
PRM-06-004 |
MAY | A CASE_MANAGER or Case Owner MAY assert d→D (D) on behalf of a Deployer-role participant, under the same externally-evidenced pattern as PRM-06-003. The target must already be a participant (PRM-06-006). This move is the whole of what the status asserts: it cannot be asserted in the same status as the v→V of PRM-06-003.Usually the deployer reports its own deployment. But a deployer that joined and has since gone quiet can leave the case unable to record a deployment the case has evidence of. The on-behalf limit keeps this narrow exception from becoming a general proxy capability, and a deployer that did not join is not in the case at all. The pair with v→V is excluded: together they are VfD, which CSB-17-001 does not enumerate, and PRM-06-008 already has the entailments refuse it. |
Uses definition from: PRM-06-003 |
PRM-06-008 |
MUST | The actor processing an on-behalf d→D assertion MUST apply the cross-machine entailments, so it succeeds only for a deployer whose RM state fits deployment.The on-behalf path is an exception to self-declaration, not a way around the rules every status write obeys. Without the entailments, it could record a deployment for a deployer that never accepted the report. |
Extends: PRM-06-004 |
PRM-06-005 |
MUST NOT | The f→F transition (fix ready, VF) MUST NOT be asserted by any actor other than the Vendor-role holder. Fix readiness is not externally knowable; no on-behalf assertion is ever permitted for this transition (ADR-0121). Allowing a non-vendor to assert fix-readiness would let the CASE_MANAGER fabricate protocol-visible fix state, undermining the meaning of the F event. |
|
PRM-06-006 |
MUST | An actor processing an on-behalf status assertion MUST refuse it before any write if its target is not a case participant, creating no participant. A status update is never a way into a case; joining is the Invite flow (CM-11, ADR-0114). If a status update creates the participant that it names, it is a second path into a case. That path skips the Invite flow and its consent and entitlement checks. If the record is created before the status write, and the write is then refused, a stray participant stays. For example, the RM-to-D entailment refuses d to D for a target that did not accept the report. |
Constrains: PRM-06-003 Constrains: PRM-06-004 |
Publishing a fix is not deploying it
A vendor that publishes a patch has made the patch available. It has not deployed it: deployment happens in the systems that run the product, and it is a Deployer's act. Fix Ready and Fix Deployed are therefore distinct protocol facts, and neither is inferred from the other.
The same separation applies to public awareness. A notification that information is public sets Public Aware, which is world state. It does not set Fix Deployed, which is participant state requiring the Deployer role. An implementation that treats publication as deployment produces an unauthorized VFD advance.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CSB-15-003 |
MUST | A participant that reports that the vulnerability is public MUST record only the P event (pxa → Pxa) in its participant status. Conflating P and D transitions causes non-deployer actors (Finders, Reporters, Coordinators) to incorrectly acquire deployment state when they announce public disclosure. The P event is participant-agnostic; the D event is valid only for a DEPLOYER participant that has separately completed deployment (CSB-15-002). ECA DetailsPreconditions - A participant reports that the vulnerability is public Steps 1. [participant] Record P (Pxa) in its participant status → Public awareness recorded Postconditions - The participant status records P |
|
CSB-15-011 |
MUST NOT | A participant's report of the P event MUST NOT also advance its d dimension. The D event (fix deployed) is participant-specific and distinct from the P event (public awareness). A participant that reports fix deployment reports it separately, and must hold the DEPLOYER role (CSB-15-002). ECA DetailsSteps 1. [participant] Leave the vf and d dimensions unchanged (do not advance d to D) → vf and d reflect prior state; D event not triggered by P event Postconditions - The participant status's vf and d dimensions are unchanged |
Refines: CSB-15-003 |
Open question: disputing an asserted vendor awareness
The first VFD transition — v→V, vendor becomes aware — has two drive paths.
The vendor can report it for itself, and the CASE_MANAGER or the Case Owner can assert it on the vendor's behalf (§13.4.1 Participant-Specific CS Transitions (VFD)).
The protocol expects evidence of the notification to ground that assertion, and the reference implementation does not check for it.
Open questions: can the subject Vendor dispute an awareness that another party asserted for it? Is transport-level delivery success, a Hypertext Transfer Protocol (HTTP) 200 response, enough evidence for the assertion?
Do not infer a rule from this document's silence.
13.4.2 Participant-Agnostic CS Transitions (PXA)
PXA records the state of the world rather than the state of any participant, so these transitions are not scoped to a role. Anyone can notice that a vulnerability has become public.
Recall: public/exploit/attacks axes
| Axis | Not yet | Set | Meaning when set |
|---|---|---|---|
| Public Aware | p |
P |
The vulnerability is known outside the case participants |
| Exploit Public | x |
X |
An exploit for the vulnerability has been published |
| Attacks Observed | a |
A |
Attacks exploiting the vulnerability have been seen |
Full definitions are in §8.2 PXA — Public Aware, Exploit Public, Attacks Observed.
Because PXA is world state, any participant can report a PXA observation, whatever roles it holds. These transitions are role-ungated: information can become public, exploits can appear, and attacks can be observed independently of anything a case participant does or causes.
p→P(publicly aware): any participant can report itx→X(exploit public): any participant can report ita→A(attacks observed): any participant can report it
A participant reports an observation in the case status that its own participant status carries.
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
RSH-09-009 |
MUST NOT | A received ParticipantStatus MUST NOT be refused for the sender's case roles over the public-state (P/X/A) values that its embedded CaseStatus states. A participant holding any role, OBSERVER alone included, can report that the vulnerability is public, that an exploit is public or that attacks are observed. Adoption decides whether a reported value becomes canonical case state (RSH-01-003), not the acceptance rules.P, X and A record the state of the world, not anything a participant did, so no role owns them. A Vendor cannot be the only party able to say that an exploit is public: an Observer or a monitoring service is often the first to see it. The adoption gate, not a role check, protects canonical case state from a wrong report. |
Extends: RSH-09-003 See also: RSH-01-003 — context for the reader |
MSM-03-004 |
MUST | Protocol shorthand CP (Public Aware) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes public awareness (P) in its pxaState.A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001). |
Uses definition from: VAM-08-002 Derives from: RSH-04-001 See also: RSH-04-005 — context for the reader |
MSM-03-005 |
MUST | Protocol shorthand CX (Exploit Published) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes a published exploit (X) in its pxaState.A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001). |
Uses definition from: VAM-08-002 Derives from: RSH-04-001 See also: RSH-04-005 — context for the reader |
MSM-03-006 |
MUST | Protocol shorthand CA (Attacks Observed) MUST have the semantic type ADD_PARTICIPANT_STATUS_TO_PARTICIPANT when a participant reports it, which it does only in the CaseStatus that its Add(ParticipantStatus, target=<participant>/statuses) embeds (RSH-04-001), and the semantic type ADD_CASE_STATUS_TO_CASE when it is carried in Add(CaseStatus, target=<case>/statuses) (VAM-08-002), the CASE_MANAGER's record of the case status it adopted (RSH-04-001, RSH-04-005). In both forms the CaseStatus payload encodes observed attacks (A) in its pxaState.A participant embeds its suggested CaseStatus in Add(ParticipantStatus) (RSH-04-007), so the formal message has one wire form per sender. The participant's is its view, not a change: the CASE_MANAGER adopts it, a non-owner's by default only with the Case Owner's authorization (RSH-07-001, RSH-07-006), as its own Add(CaseStatus) ledger entry (RSH-01-003), and a receiver refuses an Add(CaseStatus) from anyone else (RSH-04-005). Each form dispatches to its own entry (MSM-08-001). |
Uses definition from: VAM-08-002 Derives from: RSH-04-001 See also: RSH-04-005 — context for the reader |
Reporting is not adoption. A reported observation is a claim. Whether it becomes canonical case state, and whether it triggers embargo teardown, is decided by the CASE_MANAGER, following §11.3 Status Adoption: One Authorization Gate and subject to Case Owner authorization by default. The role rule here — who can report — is deliberately separate from the authorization rules there — what the CASE_MANAGER does with a report.
Informative: automated observers
An actor can be an automated service that monitors external sources — threat feeds, public disclosures, vulnerability databases — and reports what it finds into a case. Such a service is not a distinct protocol role: it reports PXA observations on the same terms as any other participant, and its reports are adopted through the same authorization as theirs (§11.3 Status Adoption: One Authorization Gate).
13.4.3 CVE ID Assignment
Assigning CVE IDs happens outside the protocol, so this section states no protocol requirement for it. It describes how the CVE Numbering Authority (CNA) role fits into a case.
An actor holding the CNA role can assign CVE IDs. Assignment includes evaluating the vulnerability against the eligibility criteria first.
An actor that does not hold the CNA role delegates ID assignment. It can delegate to an external CNA service, or to another participant in the same case that holds the CNA role. A coordinator or vendor acting as a CNA can do the assignment without the case leaving the protocol.
Eligibility criteria posture. This specification does not cite a specific edition of the CNA Operational Rules, and it does not treat eligibility checks as fully implementation-defined. Instead, the reference implementation follows CNA Operational Rules v4.1.0 as its baseline. Adopting a newer edition means updating the specification and the implementing call-out. This avoids coupling the Request for Comments (RFC) to the release cycle of an independently-versioned external document, while remaining transparent about which edition the reference implementation follows.
Eligibility checking is a single logical capability: the full set of criteria applied as a unit against one rules edition. The protocol treats it as one decision with one outcome, and does not specify how an implementation reaches that decision.
Reference implementation note
The Python reference implementation checks CVE eligibility with one EvaluateCveEligibility Evaluator call-out point, as BTND-05-007 describes.
Three named checks come before it as separate call-out points: InScope, ProductInCNAScope and IsMostAppropriateCNA.
The publication condition, IsOrWillBePubliclyDisclosed, reads case state directly and is not a call-out point.
13.4.4 Case Owner Authority
Adopting a reported status as canonical case state is the Case Owner's decision. The Case Owner is the party whose disclosure decision the case exists to serve, so it is the party entitled to decide what the case asserts. By default the protocol therefore has the CASE_MANAGER ask for the Case Owner's authorization before it adopts a participant's reported status.
One case is exempt. Where the Case Owner is itself the sender, the CASE_MANAGER adopts the status without asking: asking the Case Owner to approve its own report would be circular.
§11.3 Status Adoption: One Authorization Gate states both rules and the permissive configuration an implementation can choose instead.
The reference implementation's main branch does not yet send the authorization request, and Known Gaps lists that request as not yet met, tracked by #2885.
Section 11.3 says what main does meanwhile.
13.5 Conformance Testing Approach
Conformance is judged from outside the implementation. A test supplies a sequence of messages and an input state, and checks the messages the implementation emits and the state it reaches. It does not inspect internal structure.
Each test case is therefore a message-sequence scenario paired with the state outcome it expects.
Some capabilities that define a role are not protocol-observable at all. Developing a fix, deploying a fix and publishing an advisory happen outside the protocol. Conformance verifies the protocol messages that this work produces, not the work itself.
Conformance testing is organized in four layers, which describe what a test verifies. Layers are orthogonal to the capability sets of §13.2 Capability Sets, which describe what an implementation provides (see the warning in §13.1 Conformance Model Overview):
| Layer | Verifies |
|---|---|
| L1 — Syntax | Messages are well-formed against the wire format (§5 Encoding and Transport) |
| L2 — Semantics | Each message drives the correct state transition (§4 Messages, §6 Report Management (RM) State Machine through §12 Participant Lifecycle Within a Case) |
| L3 — Behavior | Correct observable outputs: right messages emitted and states reached, given input state plus received message |
| L4 — Process | Correct internal decision structure (e.g. precondition before state write before side-effect) |
L4 is only enforceable against a reference implementation and is therefore outside the scope of independent conformance claims. Some process ordering surfaces at L3 where the output sequence is itself observable — the canonical-write-before-side-effects rule of §11.3 Status Adoption: One Authorization Gate being the clearest case.
See also
- Process Models — the behavioral material the L2 and L3 layers test against
13.6 Capability Shapes
Capability shapes describe optional, pluggable capabilities that an implementation can connect to its own decision points. They are not part of the Case Observer, Case Decision or Case Hosting capability sets, and a conformance claim does not state which shapes an implementation provides.
A capability shape is a contract between an implementation and the capability it connects, not a protocol rule: other participants cannot observe which shapes an implementation uses. An implementation that provides a shape keeps to that shape's contract. The shapes and their contracts are described in Annex G Capability Shapes.