Protocol Specification Known Gaps
This page lists each protocol and foundation requirement of the Vultron Protocol Specification that the tests do not show the main branch of the reference implementation fully meets.
It is generated from the tests on main, so it cannot fall behind them.
When the tests show that main meets all of a requirement, the requirement leaves this page.
The page has three sections.
The first lists the requirements that a test shows main does not yet meet, with the issues that track the work.
Their rows in the Requirements Catalog, and every callout of them, carry the marker "Not yet in the reference implementation".
The second lists the requirements that main meets only in part.
Some of their tests pass, but at least one test is held as an expected failure or a skip, and the section names the issues that track the held part.
The third section lists the requirements that no test checks.
A requirement in the third section is not known to be missing from main: no test shows main does it.
The page describes the reference implementation, not the protocol. For the questions that the specification itself leaves unresolved, see Open Questions. Each requirement links to its row in the Requirements Catalog.
Requirements a test shows main does not yet meet
Each requirement below has tests, and every one of them is held by a strict expected failure (xfail) or a skip.
So a test shows that main does not yet meet the requirement.
The requirements are grouped by the issues that the held tests cite.
Tracked by #1184
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ENC-01-001 |
MUST | Not yet in the reference implementation (tracked by #1184) Each actor MUST generate a unique asymmetric key pair when its identity is first provisioned. Key material binds to an actor identity, not to a case. An actor that enacts CVDRole.CASE_MANAGER for several cases uses one key pair for all of them, so per-case key separation is a consequence of deployment topology rather than a key-binding rule. Regenerating a key pair would invalidate any peer's cached public key and break encrypted communication mid-case. See notes/encryption.md for the topology discussion. |
|
ENC-01-004 |
MUST | Not yet in the reference implementation (tracked by #1184) An implementation MUST store each private key securely. Anyone who obtains an actor's private key can read messages encrypted to it, including embargoed vul details, and can forge activities in its name. |
|
ENC-01-005 |
MUST | Not yet in the reference implementation (tracked by #1184) An actor's asymmetric key pair MUST be persisted and reused across process restarts for the lifetime of that actor identity. Regenerating on restart would invalidate any peer's cached public key and break encrypted communication mid-case. |
Extends: ENC-01-001 |
ENC-01-006 |
MUST NOT | Not yet in the reference implementation (tracked by #1184) A new key pair MUST NOT be generated on process resumption for an existing actor identity. Generating a new key pair on restart breaks any encrypted channel established with the previous key, invalidating cached public keys held by case participants. |
Extends: ENC-01-001 |
Tracked by #2883
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-01-004 |
MUST | Not yet in the reference implementation (tracked by #2883) An actor MUST determine the action that a reply authorizes from the ask the reply answers, not from the content of the reply. Generalizes ADR-0026's trust rule; reading the action from the reply lets the answerer unilaterally alter what it authorizes. |
|
ASK-02-003 |
MUST | Not yet in the reference implementation (tracked by #2883) When an ask for the same kind and subject is already outstanding and unexpired, the actor MUST NOT emit a second ask. Re-asking an open question produces duplicate decisions for the answerer and duplicate register entries for the asker. |
|
ASK-06-001 |
MUST | Not yet in the reference implementation (tracked by #2883) A case-scoped ask MUST be recorded as a canonical CaseLedgerEntry.An outstanding decision, and a stalled one, is protocol-relevant to every participant. |
|
ASK-06-002 |
MUST NOT | Not yet in the reference implementation (tracked by #2883) An ask MUST NOT carry content that cannot be disclosed to every participant of its case. Asks replicate to all participants (ASK-06-001), so private rationale must travel by a directed Note instead. |
|
ASK-06-003 |
MUST | Not yet in the reference implementation (tracked by #2883) The ledger entry of a case-scoped ask MUST replicate to case participants on the normal fan-out path. Every participant needs to see an outstanding decision. A directed-delivery variant would require redaction with proofs, which does not exist. |
Extends: ASK-06-001 |
Tracked by #2883 and #3918
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-04-010 |
MUST | Not yet in the reference implementation (tracked by #2883 and #3918) This rule covers the CASE_MANAGER relaying an ask on a participant's behalf (CM-24-001, CM-24-002; EP-09-002). It MUST record each relayed ask in its own outstanding-ask register as the asker. ASK-04-001 says the emitter records; a relayed Invite's actor is the CASE_MANAGER with the proposer in attributedTo, so the manager is the emitter and the one that owes the bookkeeping. |
Uses definition from: CM-24-001 See also: CM-24-002 — context for the reader See also: EP-09-002 — context for the reader |
ASK-04-013 |
MUST NOT | Not yet in the reference implementation (tracked by #2883 and #3918) A participant whose proposal the CASE_MANAGER relays MUST NOT record the relayed Invites in its outstanding-ask register. It records only its own proposal to the CASE_MANAGER. The participant did not emit the relayed Invites (ASK-04-001). Giving it a register entry for each one would let it reap or re-ask on the manager's behalf. |
Extends: ASK-04-010 |
Tracked by #2884
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-03-001 |
MUST | Not yet in the reference implementation (tracked by #2884) Each ask kind MUST declare the set of reply semantic types that close it. Pairing a reply to an ask requires a declared closing set rather than hard-coded reply names at call sites; ProtocolPair already carries this field. |
|
ASK-03-004 |
MUST | Not yet in the reference implementation (tracked by #2884) An ask activity MUST carry its own deadline in the AS2 endTime field.Placing the deadline on the wire means the answerer reads the same value as the asker, so a configurable duration cannot cause disagreement. |
|
ASK-03-006 |
MUST NOT | Not yet in the reference implementation (tracked by #2884) An action gated by an ask whose kind declares void expiry MUST NOT be performed on the strength of a reply recorded after the ask's deadline. An authorization granted against a case state that no longer holds is a standing permission, which is the hazard ADR-0026's trust rule addresses in the identity dimension. |
Tracked by #2884 and #3918
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-03-007 |
MUST | Not yet in the reference implementation (tracked by #2884 and #3918)Invite(EmbargoEvent) is an ask kind. Its closing replies are Accept(Invite(EmbargoEvent)) and Reject(Invite(EmbargoEvent)) from the invitee; its deadline is the Invite's endTime (CM-28-001, CM-28-012); its expiry consequence is stale, not void: a reply after the deadline is still honoured under EMB-17 once the expiry has been recorded as TIMED_OUT (CM-18-002).The embargo invitation already has every property an ask kind declares, and the relay (EP-09) emits one per participant per proposal, so the outstanding-ask register must track it without a special case. Declaring the kind here keeps find_protocol_pair's one-open-request assumption from being applied to N simultaneous Invites of one semantic type. |
Uses definition from: CM-28-001 Uses definition from: CM-18-002 See also: CM-28-012 — context for the reader |
Tracked by #2885
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-01-001 |
MUST | Not yet in the reference implementation (tracked by #2885) An actor that cannot perform an action on its own authority MUST request authorization with an ask activity addressed to the authorizing actor. Separates requesting authority from holding it, so the action cannot occur on the asker's own initiative. |
|
ASK-02-005 |
MUST | Not yet in the reference implementation (tracked by #2885) While an ask for authorization (ASK-01-001) is outstanding, the asking actor MUST leave the case in a state the protocol defines. An ask suspends nothing, so the case sits in the pre-authorization state for the whole deadline; that state must be legitimate. |
Uses definition from: ASK-01-001 |
ASK-02-006 |
MUST | Not yet in the reference implementation (tracked by #2885) An actor MUST refuse, not ask about, an action whose not-yet-authorized state the protocol cannot represent. Asking would leave the case in an undefined state for the whole ask deadline (ASK-02-005), so such an action can only be refused. |
Derives from: ASK-02-005 |
Tracked by #2887
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-05-004 |
MUST NOT | Not yet in the reference implementation (tracked by #2887) Reaping an expired ask MUST NOT re-emit it automatically. Mirrors CLP-06-005 — a timeout is a signal, not an instruction to retry. |
|
ASK-05-005 |
MUST | Not yet in the reference implementation (tracked by #2887) After an ask expires, the actor MUST re-ask only when it decides anew to perform the gated action. The tree owns the decision because only it knows whether the action is still wanted. |
Extends: ASK-05-004 |
Tracked by #2889
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-07-007 |
MUST | Not yet in the reference implementation (tracked by #2889) Receiving a processing fault that refers to an outstanding ask MUST close that ask's register entry. The exchange cannot complete, so leaving the entry open costs the asker its whole deadline for a failure already reported. |
|
ASK-07-013 |
MUST | Not yet in the reference implementation (tracked by #2889) A ProcessingFault MUST be structured according to RFC 9457 Problem Details.RFC 9457 is the standard for machine-readable error reporting over HTTP. |
Extends: ASK-07-005 |
Tracked by #2890
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CP-05-007 |
MUST | Not yet in the reference implementation (tracked by #2890) A report receiver that has sent Create(CaseProposal) and has no reply by the proposal's deadline MUST stop waiting and treat the proposal as expired. A reply is an Accept(CaseProposal) or a Reject(CaseProposal).Without a deadline, a lost Accept stops the handshake for good, because no party waits with a timeout. The proposal is an ask (ASK-01-001), so it carries a deadline (ASK-03-004) and the report receiver records it with its other outstanding asks (ASK-04-001). That record belongs to the actor, so it works before a case exists. To propose again is a new decision, not an automatic retry (ASK-05-005), and a repeated proposal is also how the CASE_MANAGER gets a chance to answer again (CP-05-006). |
Refines: ASK-05-001 |
Tracked by #3355
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
SM-09-002 |
MUST NOT | Not yet in the reference implementation (tracked by #3355) The CS state machine MUST NOT allow a state in pattern vF* (fix ready, vendor unaware) or *fD* (fix deployed, fix not ready).A vendor cannot have deployed a fix ( D) without first having one ready (F); a fix cannot be ready (F) if the vendor is unaware (v) of the vulnerability. Together, SM-09-001 and this rule reduce the theoretical 64-state CS space to the 32 reachable CS states: 4 valid VFD combinations (vfd, Vfd, VFd, VFD) × 8 PXA combinations. See docs/reference/formal_protocol/states.md for the formal derivation. Note: the "40-state" figure in the formal protocol paper refers to the global case state space (8 PXA × 5 EM), not to CS alone. |
Tracked by #3659
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
SYNC-01-008 |
MUST | Not yet in the reference implementation (tracked by #3659) A CaseLedgerEntry's hash MUST be computed over the RFC 8785 (JCS) serialization of the content it covers, payload snapshot included.Every receiver recomputes an entry's hash and refuses a mismatch (SYNC-03-006, SYNC-03-012). A peer built in another language reproduces the hash only if the bytes it hashes are fixed by a published rule, not by one serializer's behavior. JCS is that rule: it fixes key order, number form and string escaping, and the signing cryptosuite already uses it (SIG-01-002). |
Extends: SYNC-01-003 |
Tracked by #3698
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-06-004 |
MUST NOT | Not yet in the reference implementation (tracked by #3698) This rule covers a reporter that has offered one report to several recipients. It MUST NOT let a further offer, or its acceptance of one bootstrap, change how it treats another recipient's bootstrap. That covers whether it accepts the bootstrap and which case it records for that recipient. Each recipient's case stands on its own trust anchor. If one recipient's bootstrap could displace another's, the order in which the bootstraps arrive would decide which case the reporter can join. |
Extends: CBT-06-002 |
Tracked by #3702
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-32-025 |
MUST NOT | Not yet in the reference implementation (tracked by #3702) When it merges cases, the CASE_MANAGER MUST NOT record a merged case in any case's child_cases.Only a split writes child_cases (CM-32-005), so a merged case never joins a split family. Keeping merges out of child_cases leaves the merge spec the other two link fields (ADR-0105). |
Derives from: CM-32-006 |
Tracked by #4241 and #4242
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-32-001 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) To split a case, the parent case's Case Owner MUST send Create(CaseProposal) to the parent's CASE_MANAGER, with the activity's context naming the parent case.The parent's Owner decides what the parent's coordination becomes, as it does for an ownership transfer or a merge (ADR-0053, ADR-0105). The parent context is what tells a split apart from a report-born proposal, whose sender entitlement differs (HP-01-006). |
|
CM-32-002 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST answer a split proposal (CP-05) to the Owner with Reject(CaseProposal), or with Accept(CaseProposal) naming the child in result and then Create(VulnerabilityCase).Reusing the proposal answer gives the split the admission decision and the one-act creation the creation flow already has, rather than a second creation path to keep in step with it. |
Refines: CP-05-002 Extends: CP-05-003 |
CM-32-003 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The parent's CASE_MANAGER MUST create the child case in its own store. The split creates a case like any other (CP-09-001, ADR-0041). Creating it in the store that already holds the parent keeps the whole family at one CASE_MANAGER (CM-32-019). |
Refines: CP-09-001 |
CM-32-004 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST create a child case with parent_cases holding exactly the parent case's ID, and with child_cases and sibling_cases empty.The child must know the case its embargo came from, so its CASE_MANAGER can route VP-10 notices. |
|
CM-32-005 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) After it commits the child case's creation entry, the CASE_MANAGER MUST add the child's ID to the parent's child_cases, committed as one parent ledger entry.Ordering the parent entry after the child's creation means the parent never names a case that does not exist. One write per split keeps the links consistent. |
|
CM-32-006 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST read a split family as a parent case with the cases its child_cases lists. A child's siblings are the other cases in its parent's child_cases. A case that is both a child and a parent belongs to both families. A notice it owes under CM-32-013 or CM-32-014 goes to every other member case of each.The parent stays open after a split, so it is coordinated alongside its children and counts as their sibling for VP-10-002 and VP-10-003. Reading siblings from the parent needs no stored sibling list, because one CASE_MANAGER hosts the parent and every child (CM-32-019, CM-32-016). |
|
CM-32-007 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) This rule covers a split whose parent case has an active embargo. The CASE_MANAGER MUST give the child a new EmbargoEvent, scoped to the child, with the active embargo's end time, active from creation.VP-10-005 transfers the embargo; ADR-0125 limits the transfer to its terms. A new embargo object keeps consent per (participant, embargo) (ADR-0122): a child participant consents to the child's embargo, and its answer says nothing about the parent's. |
Refines: VP-10-005 Supersedes: CM-14-010 Part of: CM-32-011 |
CM-32-008 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) When the parent case has no active embargo at the split, the CASE_MANAGER MUST NOT give the child an embargo. The child inherits the parent's embargo state, not a default: a parent whose embargo has ended or was never agreed must not gain an embargoed child the parent's participants never agreed to. |
Part of: CM-32-011 |
CM-32-009 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT give a child case any of the parent's reports, notes, ledger entries, participants, case statuses, vulnerability items or case references. The split exists to keep the child's participants apart from the parent's content. Creating the child empty and adding only what the splitter wrote makes isolation the default; copying and pruning would disclose whatever the pruning missed. |
|
CM-32-010 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The Case Owner MUST include in its split proposal a new VulnerabilityReport attributed to itself, and the stub summary for the child's stub Invites (CM-17-010).Every case has a report (CM-05-002). A report the splitter writes for the child is the child's fresh description. The splitter, not the CASE_MANAGER, decides how much an invitee not yet bound by the embargo may learn from the stub (CM-17-010). |
Uses definition from: CM-17-010 |
CM-32-011 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST initialize a child case by the sequence of CM-14-001, with CM-32-007 or CM-32-008 in place of its embargo step (CM-14-010). A child is a case like any other, so it starts from the same sequence. Its embargo comes from the parent, not from the creation-time default. |
Supersedes: CM-14-001 See also: CM-14-010 — context for the reader |
CM-32-012 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT add a participant to the parent case's roster because of a child-case activity. Joining the child is joining the child only. A participant in both cases, such as the Owner, is a participant of each separately. |
|
CM-32-013 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) This rule covers a child case's CASE_MANAGER that commits an embargo proposal or revision ending earlier than the end time the child inherited. Before the proposal is activated, it MUST commit a split-family embargo notice to each other member case's ledger in the child's family (CM-32-006). This is how VP-10-002 is carried out. An earlier end in one child can reveal the vulnerability in the products the others cover (VP-10, split discussion), so the other cases hear of it while it is still a proposal. |
Implements: VP-10-002 Uses definition from: CM-32-006 |
CM-32-014 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) When the active embargo of any member of a split family changes — a revision is activated or the embargo is terminated — the family's CASE_MANAGER MUST commit a split-family embargo notice to the ledger of every other member case of the family (CM-32-006), carrying the changed member's ID, its new end time or the fact of termination, and the rationale when the change's proposal gave one. This is how VP-10-003 is carried out. Participants address case messages only to their CASE_MANAGER (PCR-08-001), and every member case has the same CASE_MANAGER (CM-32-016), so a change agreed in one case reaches the others' participants through their own ledgers rather than from participant to participant. |
Implements: VP-10-003 Uses definition from: CM-32-006 |
CM-32-015 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER of a member case MUST be the only actor that commits a split-family embargo notice to that case's ledger. Committing the notice to the receiving ledger delivers it through the shared recipient selection (CM-10-004). The participants of one case thus learn of another's change without ever being addressed by it. |
Constrains: CM-32-014 |
CM-32-016 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) While a case belongs to a split family, its CASE_MANAGER role MUST NOT be delegated to any actor but the CASE_MANAGER of the other members. Siblings are read from the parent (CM-32-006), and notices are ledger commits by the one CASE_MANAGER hosting the family (CM-32-013, CM-32-014). A member moved to another CASE_MANAGER could neither find its siblings nor reach them. ADR-0125 leaves a family spread across CASE_MANAGERs to a later decision. |
Extends: CM-02-014 |
CM-32-017 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST refuse a split proposal whose sender does not hold CASE_OWNER on the parent case, creating no case and leaving the parent unchanged.Only the parent's Owner may decide to split the parent (CM-32-001). A refusal that created a case, or changed the parent, would let any participant reshape a case it does not own. |
Extends: CM-32-001 Refines: HP-01-006 |
CM-32-018 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT create a second child case for a redelivered split proposal with the same proposal identifier (CP-05-013). A split proposal is a Create(CaseProposal), so it takes the duplicate handling the creation flow already has. A second child for one request would split one family into two. |
Extends: CM-32-002 Refines: CP-05-013 |
CM-32-019 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The parent's CASE_MANAGER MUST be the CASE_MANAGER of each child case it creates. The child has a CASE_MANAGER from creation (CM-02-014). Hosting the whole family at one CASE_MANAGER (CM-32-016) is what lets siblings be read from the parent (CM-32-006). |
Extends: CM-32-003 |
CM-32-020 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST set the child case's attributed_to to the Case Owner that requested the split.As in any case creation, the proposer owns the case it asked for (CP-09-001). The splitter is the Owner the child's ledger and roster start from. |
Extends: CM-32-003 |
CM-32-021 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST derive the child case's genesis hash from the child's own ID, creation time and Owner (CLP-08-002), never from the parent's. The child has a ledger of its own that shares no chain with the parent's. A genesis hash taken from the parent would tie the two chains together. |
Extends: CM-32-003 Refines: CLP-08-002 |
CM-32-022 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST record a split's case cross-references as case IDs, never as embedded cases. Related cases are the exception ADR-0017 made to the full-object rule. An embedded parent would also carry the parent's content into the child (CM-32-009). |
Extends: CM-32-004 |
CM-32-023 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) A replica of the parent case MUST take the child link from the parent ledger entry of CM-32-005. A replica copies the case from the CASE_MANAGER's ledger and never writes the case itself (ADR-0124). A link a replica wrote on its own could name a child the CASE_MANAGER never committed. |
Depends on: CM-32-005 |
CM-32-024 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT write sibling_cases on any case as part of a split.No existing sibling changes when a new child appears, because siblings are read from the parent (CM-32-006). That leaves sibling_cases free for the merge spec (ADR-0105). |
Extends: CM-32-005 |
CM-32-026 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) When the CASE_MANAGER gives a child case a new embargo under CM-32-007, it MUST write the child Owner's consent row for that embargo as AGREED.The Owner asked for the split and so agrees to the terms the child inherits. Its AGREED row is what makes it read as the new embargo's signatory (ADR-0122). |
Extends: CM-32-007 |
CM-32-027 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) When it splits a case with an active embargo, the CASE_MANAGER MUST NOT carry the parent embargo's consent rows over to the child. Consent is per (participant, embargo) (ADR-0122). A parent participant's answer to the parent's embargo says nothing about the child's. |
Extends: CM-32-007 |
CM-32-028 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) When it splits a case with an active embargo, the CASE_MANAGER MUST NOT give the child the parent's open embargo proposals or revisions. ADR-0125 limits the transfer to the active embargo's terms. A proposal still open in the parent belongs to the parent's negotiation. |
Extends: CM-32-007 |
CM-32-029 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) When a split's parent case has no active embargo, the CASE_MANAGER MUST NOT run the creation-time default embargo initialization (CM-14-010, EP-04-012) for the child. The default would give the child an embargo that CM-32-008 forbids. The parent's participants never agreed to an embargoed child. |
Extends: CM-32-008 Supersedes: CM-14-010 See also: EP-04-012 — context for the reader |
CM-32-030 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST begin a child case's ledger at the child's own genesis hash. A child ledger that chained from a parent entry would carry the parent's history into the child (CM-32-009). |
Extends: CM-32-009 |
CM-32-031 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST make the split proposal's report the child case's only report. The splitter's report is the child's description. Any other report would come from the parent (CM-32-009). |
Extends: CM-32-010 |
CM-32-032 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST put the split proposal's stub summary in each stub Invite it sends for the child case. The splitter chose what an invitee not yet bound by the embargo may learn (CM-17-010). A summary the CASE_MANAGER chose for itself could reveal more. |
Extends: CM-32-010 Uses definition from: CM-17-010 |
CM-32-033 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST refuse a split proposal whose report is one of the parent case's reports, or that carries no stub summary. Refusing a parent report keeps the parent's description out of the child (CM-32-009). With no stub summary, the child's stub Invites could carry nothing the splitter chose (CM-17-010). |
Extends: CM-32-010 |
CM-32-034 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST skip the reporter steps of case initialization (CM-14-011, CM-14-012) when it initializes a child case. The child has no outside reporter; the Owner wrote its description. |
Extends: CM-32-011 Supersedes: CM-14-011 Supersedes: CM-14-012 |
CM-32-035 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST seat only itself and the Owner when it initializes a child case, the Owner holding CASE_OWNER at RM.RECEIVED (CM-14-009). These two are the participants seated by case initialization for CM-10-004.Every other participant joins the child by accepting its stub Invite (ADR-0114), so it gets the child's content only once it is active (CM-10-004). |
Extends: CM-32-011 Uses definition from: CM-10-004 Refines: CM-14-009 |
CM-32-036 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT give the splitter the Reporter role for authoring the child's report. The splitter wrote the child's description as its Owner, not as an outside reporter. A Reporter role would claim a report the child never received from outside. |
Extends: CM-32-011 |
CM-32-037 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT invite a participant to a child case before it commits the child's creation entry (CM-14-007). An Invite sent before the creation entry would name a case the ledger does not yet hold, as for any case (CM-14-007). |
Refines: CM-14-007 |
CM-32-038 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The parent case's recipient selection (CM-10-007) MUST NOT return a participant of the child case that is not separately a participant of the parent. The recipient selection is the one place that decides who gets case content (CM-10-007). A child participant it returned would get the parent's content. |
Uses definition from: CM-10-007 |
CM-32-039 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT send a parent ledger entry to a child-case participant that is not separately a participant of the parent. Parent content reaches a participant in both cases only as a parent participant. Keeping the child apart from the parent's content is why the split exists. |
Refines: CM-10-004 |
CM-32-040 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) A split-family embargo notice under CM-32-013 MUST carry the child's ID, the proposed end time and the proposer's rationale. The other cases need to know which case wants the earlier end, how much earlier, and why, to weigh the risk to their own products. |
Extends: CM-32-013 |
CM-32-041 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) For a proposal under CM-32-013, the child's CASE_MANAGER MUST commit the proposer's rationale to the child's ledger. The reason for the earlier end is then on record in the case that asked for it, as well as in the cases it was sent to. |
Extends: CM-32-013 |
CM-32-042 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The rationale of a proposal under CM-32-013 is the proposing activity's content. The child's CASE_MANAGER MUST refuse such a proposal whose content is empty.The activity's content carries the rationale because embargo proposals have no rationale field of their own. With no rationale, the notice would tell the other cases nothing about why. |
Extends: CM-32-013 |
CM-32-043 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT change the receiving case's EM state or any consent row when it commits a split-family embargo notice. A notice informs and proposes nothing: a case's embargo changes only through its own negotiation (ADR-0125). |
Extends: CM-32-015 |
CM-32-044 |
MUST NOT | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST NOT put content of the reported case in a split-family embargo notice beyond three items. These are that case's ID, its new end time or the fact of termination, and the rationale. The participants of the receiving case may not be participants of the reported one. They learn of its change, and nothing else of that case. |
Extends: CM-32-015 |
CM-32-045 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) The CASE_MANAGER MUST refuse a delegation that CM-32-016 forbids, leaving the case's CASE_MANAGER unchanged. A refusal tells the requester that the delegation did not happen, rather than leaving it to find out from a family split across CASE_MANAGERs. |
Extends: CM-32-016 |
VP-10-002 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) If a child case following a case split requires an embargo end time earlier than the inherited date, the CASE_MANAGER of that child case SHALL notify the CASE_MANAGERs of all sibling child cases before the earlier end time takes effect, documenting the rationale in the case ledger. Child cases from one split share the same vul information, so an earlier end in one child in effect ends the embargo for its siblings too. Notifying the siblings' CASE_MANAGERs before it takes effect, with the reason on the ledger, gives their participants time to prepare and to see why. |
|
VP-10-003 |
MUST | Not yet in the reference implementation (tracked by #4241 and #4242) Participants in a child case SHALL communicate any subsequently agreed changes from the inherited embargo to the Participants of the other child cases Child cases share information that came from one parent. A change agreed in one child can change what the others may safely disclose and when, so their participants must learn of it. |
|
VP-10-005 |
SHOULD | Not yet in the reference implementation (tracked by #4241 and #4242) When a case is split into two or more parts, any existing embargo SHOULD transfer to the new cases The information in each new case was shared under the parent's embargo. Carrying the embargo over keeps it protected on terms everyone already agreed to. |
Tracked by #4596
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
HTTP-03-007 |
MUST | Not yet in the reference implementation (tracked by #4596) The API MUST return 413 Content Too Large for oversized payloads. Rejects requests exceeding the configured payload size limit (see HTTP-02-001). |
|
IE-03-003 |
MUST | Not yet in the reference implementation (tracked by #4596) Requests exceeding the maximum request body size MUST be rejected with HTTP 413. Rejecting oversized payloads with an explicit 413 prevents resource exhaustion and signals the limit violation to the sender. |
Implements: IE-03-002 Refines: HTTP-03-007 |
Tracked by #4666
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
HTTP-01-003 |
MUST | Not yet in the reference implementation (tracked by #4666) Inbox endpoint MUST reject requests with invalid Content-Type using HTTP 415 HTTP defines 415 Unsupported Media Type as the answer to a request whose content is in a format the target resource does not support. |
Implements: IE-03-001 |
HTTP-03-008 |
MUST | Not yet in the reference implementation (tracked by #4666) The API MUST return 415 Unsupported Media Type for invalid Content-Type. Rejects requests whose Content-Type header is not an accepted media type (see HTTP-01-003). |
|
IE-03-001 |
MUST | Not yet in the reference implementation (tracked by #4666) The endpoint MUST validate Content-Type header The Content-Type header tells the receiver how to read the body. A body sent as another media type may not be an ActivityStreams document. If the inbox checks the header first, it can refuse such a body with a clear answer (HTTP-01-003) before it parses the body. |
Tracked by #4667
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
HTTP-03-010 |
MUST | Not yet in the reference implementation (tracked by #4667) The API MUST return 429 Too Many Requests for rate-limit violations. Signals that the client has exceeded the permitted request rate and must back off. |
Tracked by #5388
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ENC-02-002 |
SHOULD | Not yet in the reference implementation (tracked by #5388) When sending messages to case participants, the CASE_MANAGER SHOULD encrypt each outbound message individually to an encryption key the recipient publishes in its actor profile. The specific encryption scheme (e.g., ECDH key agreement + AES-256-GCM, RSA-OAEP) is intentionally deferred pending a protocol-level agreement. Until a scheme is standardized, the choice is implementation-defined; interoperability between independently-built implementations is not yet a requirement. |
Refines: VP-15-004 |
Tracked by #5636
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
SM-09-004 |
MUST | Not yet in the reference implementation (tracked by #5636) A receiver MUST reject a CS state in the vF* or *fD* pattern (SM-09-002) at validation time.These 32 states are structurally impossible. A receiver that rejects them at validation time keeps them out of every store and replica. |
Implements: SM-09-002 |
Tracked by #5637
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
VP-05-021 |
SHOULD | Not yet in the reference implementation (tracked by #5637) An embargo that lasts more than 90 days (P90D) SHOULD carry a documented justification that all Participants agree to. Requiring agreed justification beyond 90 days makes a long embargo a deliberate exception rather than a default, since a long embargo keeps users exposed. |
Tracked by #6236
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-34-001 |
MUST | Not yet in the reference implementation (tracked by #6236) A participant that proposes a new vulnerability item for a case MUST send the CASE_MANAGER an Offer whose object is an Add of the VulnerabilityItem with the case as the Add's target.A participant's statement about what the case is about is a claim until the CASE_MANAGER admits it, as with the other things participants assert. Offering the act itself means the change the CASE_MANAGER applies on admission is exactly what the offered Add states, recorded as its own entry carrying the new item in full (CLP-07-021, ADR-0187). |
|
CM-34-003 |
MUST | Not yet in the reference implementation (tracked by #6236) A participant proposing a new case reference MUST send the CASE_MANAGER an Offer of an Add that carries the CaseReference object and targets the case.A reference is a claim about the case like an item, so it takes the same path (ADR-0187). The Add carries the CaseReference object, not its bare as:Link: a Link has no id, so the case could not list it, nor the ledger name it. |
|
CM-34-004 |
MUST | Not yet in the reference implementation (tracked by #6236) The CASE_MANAGER MUST answer an item or reference offer with an Accept when it admits the offer and a Reject when it declines it.The sender cannot tell an ignored offer from one still under review. An answer either way closes the ask (ADR-0187). |
|
CM-34-005 |
MUST | Not yet in the reference implementation (tracked by #6236) When the CASE_MANAGER admits an item or reference offer, it MUST apply the offered change to the case and commit the change as its own ledger entry after the offer's entry. Every change to the case file is its own entry, and replicas learn of items and references only from the entries they replay (CLP-07-013, CLP-07-021). |
Extends: CLP-07-021 |
CM-34-006 |
MUST NOT | Not yet in the reference implementation (tracked by #6236) The CASE_MANAGER MUST NOT change the case when it declines an item or reference offer. A decline means the claim was not admitted, so the case stays as it was. |
|
CM-34-009 |
MUST | Not yet in the reference implementation (tracked by #6236) The CASE_MANAGER MUST decline an item or reference offer from a sender that is not an active participant of the case. Only the case's active participants may make claims about it, as with their other assertions (ADR-0187). |
Tracked by #6237
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-34-002 |
MUST | Not yet in the reference implementation (tracked by #6237) A participant that proposes a change to a vulnerability item MUST send the CASE_MANAGER an Offer whose object is an Update of that item.A CVE ID is usually assigned after the item exists, so the case learns of it as a change to that item, not as a second item for the same vulnerability (ADR-0187). |
|
CM-34-007 |
MUST | Not yet in the reference implementation (tracked by #6237) An admitted update of a vulnerability item MUST replace the fields the update supplies and leave every other field of the item unchanged. This is the partial-update meaning ActivityStreams gives Update. Two admitted updates to different fields of one item then both survive, and a full revision is an update that supplies every field (ADR-0187). |
|
CM-34-008 |
MUST | Not yet in the reference implementation (tracked by #6237) The CASE_MANAGER MUST decline an offered update of a vulnerability item the case does not hold. An update needs an item to change. Admitting one for an unknown item would create the item by a path meant only for changes. |
|
CM-34-010 |
MAY | Not yet in the reference implementation (tracked by #6237) A CASE_MANAGER MAY admit item and reference offers automatically. Many deployments trust their participants' identifiers and references, and a human review of each would only delay the case. Others want the review, so admission is a choice, not a rule (ADR-0187). |
Tracked by #6241
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-05-010 |
MUST | Not yet in the reference implementation (tracked by #6241) When a vulnerability item carries a CVE record as its content, that content MUST conform to the CVE JSON schema (https://github.com/CVEProject/cve-schema). Tools that read a CVE record expect the CVE JSON schema, and they refuse or misread data that does not conform. A CVE ID on its own is an identifier, not a CVE record, so it carries no data for the schema to check (CM-05-008, ADR-0187). A case reference borrows only the schema's reference tag names, as the rel values of its url Link (CM-05-012); that is a vocabulary, not CVE record content, so this rule does not reach it. |
Requirements a test shows main meets only in part
Each requirement below has tests that pass and at least one test that is held by a strict expected failure (xfail) or a skip.
So the tests show that main meets part of the requirement, but not all of it.
The requirements are grouped by the issues that the held tests cite.
Tracked by #2884
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ASK-03-002 |
MUST | Each ask kind MUST declare whether a reply arriving after the ask's deadline authorizes the action (stale) or does not (void). Admitting a participant remains useful when authorized late; adopting a case status does not, because the case state the decision was made against has moved on. |
Tracked by #3698
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-06-002 |
MUST | This rule covers a reporter that has offered one report to several recipients. It MUST accept a valid bootstrap Create(VulnerabilityCase) from each, checking each against its sender (CBT-01-005) and recording its case and CASE_MANAGER for that recipient alone.A reporter often offers an unanswered report again to a Coordinator, and either recipient may then start a case. A reporter that trusts only one sender per report refuses the bootstrap from the second recipient and cannot join that case. How the reporter stores trust for each recipient is an implementation choice. This requirement controls only which bootstraps it accepts. |
Refines: CBT-01-006 Uses definition from: CBT-01-005 |
Tracked by #3918 and #3964
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-24-014 |
MUST | An actor that finds no CASE_MANAGER for a case MUST fail the act, never sending the activity directly to another participant instead (CM-24-008). An actor that finds no CASE_MANAGER reads a corrupt roster, since a case always has one (CM-02-014). A direct send to a participant would bypass the ledger and the recipient rules (PCR-08-001). It would also hide the corruption behind an apparent success. A failed act shows the corruption (ADR-0113). |
Tracked by #5265
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
AKM-02-006 |
MUST NOT | An actor MUST NOT record or send a value it does not know for a field of an object it did not author. It leaves such a field absent. A published or updated time read from its own clock is such a value, as is an inbox or outbox derived from another actor's id.A receiver cannot tell an invented value from an asserted one, so it records the invention as the object's own claim, and the case ledger then carries it in its snapshots. A value read from the sender's clock also differs on every build, so a rebuild of one activity under the same id does not match the first build (OX-06-002). |
Requirements no test checks
For each requirement below, no test shows main does this.
No test is marked for the requirement, so the test suite says nothing about whether main meets it.
It does not mean that main lacks the behavior.
The requirements are grouped by their Requirements Catalog page.
Vultron Protocol
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. |
|
VP-02-001 |
MUST | Coordinators MUST have a formally documented, publicly available mechanism for receiving reports A reporter can coordinate only with a coordinator it can reach. Taking reports from anyone is the coordinator's role, so an undocumented or private intake path leaves reporters no way in and pushes them toward uncoordinated public disclosure. |
|
VP-02-002 |
MUST | Participants MUST assign Valid cases a higher processing priority than Received (untriaged) cases and Closed cases in their case-management workflow. Valid reports are the ones known to need work, so effort spent on them is what reduces harm. Received reports are not yet judged and Closed reports need nothing more; letting either crowd out Valid work delays fixes for confirmed vuls. |
|
VP-02-003 |
MUST | Participants initiating CVD with others MUST do so from the Accepted state Accepted is the RM state in which a participant has committed to work on the report. Drawing others into a case from an earlier state would commit them to coordination the initiator has not itself agreed to pursue. |
|
VP-02-005 |
SHOULD | Vendors SHOULD have a clearly defined and publicly available mechanism for receiving reports Reporters can disclose privately to a vendor only if they can reach it. Without a known intake channel, reports are lost, sent to the wrong place, or published without coordination. |
|
VP-02-006 |
SHOULD | Participants SHOULD subject each Received report to a validation process resulting in a valid or invalid designation Not every report describes a real vul in the recipient's scope. Validation separates real reports from noise, so that case creation, embargo commitments and coordination effort go only where they are warranted. |
|
VP-02-007 |
SHOULD | Participants SHOULD have a clearly defined process for validating reports in the Received state A defined validation process makes valid and invalid decisions consistent and explainable to reporters. It also lets other participants trust what a Valid or Invalid announcement means. |
|
VP-02-008 |
SHOULD | Participants SHOULD have a clearly defined process for transitioning reports from the Received state to the Valid or Invalid states Other participants read RM transitions as signals. If the move out of Received follows no defined process, those signals carry no reliable meaning and reports can sit in Received indefinitely. |
|
VP-02-009 |
SHOULD | Participants SHOULD proceed only after validating the reports they receive Acting on an unvalidated report spends embargo commitments, coordination effort and other participants' attention on something that may not be a vul at all. |
|
VP-02-010 |
SHOULD | Participants SHOULD transition all valid reports to the Valid state and all invalid reports to the Invalid state The RM state is how a participant tells others what it concluded about a report. A report left in Received, or put in the wrong state, misinforms every participant that tracks it (VP-01-002). |
|
VP-02-011 |
SHOULD | Once a Vendor confirms that a reported vulnerability affects one or more of their products or services, the Vendor SHOULD designate the report as Valid The vendor's confirmation that its product is affected answers the question validation asks. Designating the report Valid then moves it on to prioritization and tells other participants the vendor has a real vul to fix. |
|
VP-02-012 |
SHOULD | Participants SHOULD temporarily hold reports that they cannot validate pending additional information Many reports cannot be judged on first read because details are missing. Holding them, rather than marking them Invalid, keeps a real vul from being discarded only because the reporter has not yet supplied enough information. |
|
VP-02-013 |
SHOULD | Participants SHOULD provide Reporters an opportunity to update their report with additional information before closing it Reporters can often supply the missing detail if asked. Closing without giving them that chance throws away real vuls and discourages reporters from using the coordinated channel next time. |
|
VP-02-014 |
SHOULD | For Valid reports, the Participant SHOULD perform a prioritization evaluation to decide whether to accept or defer the report A valid report still competes with all other work for limited capacity. An explicit prioritization decision turns "this is real" into "we will work on it now" or "later", and gives the participant a decision to announce (VP-02-024). |
|
VP-02-016 |
SHOULD | Participants SHOULD have a bias toward accepting rather than deferring Valid cases up to their work capacity limits Deferring a valid report leaves a known vul unaddressed and its reporter waiting. Accepting when capacity allows keeps real vuls moving toward a fix. |
|
VP-02-017 |
SHOULD | Reports SHOULD exit the Deferred state when work is resumed (to Accepted) or when the Participant has determined no further action will be taken (to Closed) Deferred is meant as a pause, not a resting place. Leaving reports there indefinitely hides whether work will ever resume, so the participant moves them on once that is known. |
|
VP-02-018 |
SHOULD | Reports SHOULD be moved to the Closed state once a Participant has completed all outstanding work tasks and has determined that no further action will be taken on the report Closed tells other participants that this participant will do no more on the report. Closing before outstanding work is done, or keeping finished reports open, misinforms the participants who track RM state. |
|
VP-02-019 |
SHOULD | CVD Participants SHOULD announce their RM state transitions to the case's CASE_MANAGER, which fans each one out to the other Participants in the case (PCR-08-001, VP-18-002). Other participants plan their own work around who is engaged with a case (VP-01-002). Announcing RM transitions is how they learn of them; an unannounced close or defer leaves them expecting work that will not happen. A participant never messages another participant directly, so the announcement reaches them through the CASE_MANAGER's fan-out. |
See also: PCR-08-001 — context for the reader See also: VP-18-002 — context for the reader |
VP-02-021 |
SHOULD | Participants SHOULD act in accordance with their own policy and process when deciding when to transition RM states Organizations differ in capacity, risk tolerance and published disclosure policy, and the protocol cannot know those. Leaving transition decisions to each participant's own policy keeps the protocol usable across them, while other requirements still make the decisions visible. |
|
VP-02-022 |
SHOULD NOT | Participants SHOULD NOT mark duplicate reports as invalid A duplicate still describes a real vul. Marking it Invalid would tell its reporter, and every participant tracking the state, that the report was wrong, and would discard any new detail it carries. |
|
VP-02-023 |
SHOULD | A Participant SHOULD move a duplicate report through the RM Valid state. Passing through Valid records that the duplicate describes a real vul, so the duplicate's reporter learns that the report was sound. |
|
VP-02-024 |
SHOULD | Vendors SHOULD communicate their prioritization choices when making either a defer or accept transition out of the Valid, Deferred, or Accepted states Reporters and other participants plan around whether a vendor will act now or later. Stating the prioritization choice lets them adjust, for example by seeking a coordinator or different embargo terms, instead of guessing from silence. |
|
VP-02-025 |
MAY | Participants MAY perform a more technical report validation process before exiting the Received state Some reports cannot be judged credible without reproducing or examining them. Allowing deeper technical checks before leaving Received keeps the Valid designation meaningful. |
|
VP-02-026 |
MAY | Participants MAY create a case object to track any report in the Received state Some participants need a record of a report and its correspondence from the moment it arrives, for example to show response times. A case at Received gives them that record without forcing it on everyone. |
|
VP-02-027 |
MAY | Participants MAY set a timer to move reports from Invalid to Closed after a set period of inactivity Invalid reports that receive no new information need no further work. A timer moves them to Closed so they do not pile up as open items, while still leaving the reporter a window to respond. |
|
VP-02-028 |
MAY | Participants MAY choose to perform a shallow technical analysis on Valid reports to prioritize further effort Prioritization is better informed when the participant knows roughly how severe or widespread the vul is. A shallow analysis gives that without committing to full work. |
|
VP-02-029 |
MAY | A report MAY enter and exit the Accepted state a number of times as a Participant resumes or pauses work Work on a report is often paused and resumed as priorities change. Allowing repeated entry into Accepted lets the RM state follow the real work instead of forcing a single pass. |
|
VP-02-030 |
MAY | A report MAY enter and exit the Deferred state a number of times as a Participant pauses or resumes work Work on a report is often paused and resumed as priorities change. Allowing repeated entry into Deferred lets the RM state follow the real work instead of forcing a single pass. |
|
VP-02-031 |
MAY | CVD Participants MAY set a policy timer on reports in the Deferred state to ensure they are moved to Closed after a set period of inactivity Deferred reports are easily forgotten. A policy timer moves them to Closed after inactivity, so open work lists reflect reality and other participants learn this participant has stopped work. |
|
VP-02-032 |
MAY | Participants MAY create a case for Invalid reports A case for an invalid report keeps the decision and correspondence on record. That record helps if the report is later revalidated (VP-02-033) or a duplicate arrives. |
|
VP-02-033 |
MAY | Participants MAY periodically revalidate Invalid reports to determine if they have become Valid A report judged Invalid may become valid as new information, product versions or exploitation evidence appears. Periodic revalidation stops an early wrong call from becoming permanent. |
|
VP-02-034 |
MAY | Participants MAY re-prioritize Accepted or Deferred cases Priorities change as information arrives, such as exploitation evidence or newly affected products. Re-prioritizing lets a participant's work, and the RM state it announces, follow that change. |
|
VP-02-035 |
MAY | Participants MAY close Accepted or Deferred cases or Invalid reports Accepted or deferred work ends, whether fixed, out of scope or abandoned, and invalid reports may need nothing more. Closing marks that end so other participants know no further action is coming from this participant. |
|
VP-03-001 |
MUST | Participants MUST be in RM Accepted to send a Report Submission (\(RS\)) message to someone else An \(RS\) hands a report to someone else and draws them into coordination. Requiring Accepted means only a participant that has committed to work on the report can pass it on, so reports are not forwarded by someone who has not judged them worth pursuing. |
|
VP-03-002 |
MUST | Vendor Recipients receiving a new Report Submission MUST transition their CVD Case State to Vendor Aware (\(q^{cs} \xrightarrow{\mathbf{V}} Vfd\cdots\)) Vendor awareness is the first CS event and starts the vendor's response timeline. If receiving a report did not set it, the case would understate what the vendor knows, and every later CS-based decision, including embargo eligibility and fix tracking, would start from a wrong state. |
|
VP-03-003 |
SHOULD | Participants SHOULD send \(RI\) when the report validation process ends in an invalid determination The reporter and other participants need to know a report was judged invalid, so they can supply more detail or pursue other channels. Without \(RI\) they cannot tell an invalid finding from no response at all. |
|
VP-03-004 |
SHOULD | Participants SHOULD send \(RV\) when the report validation process ends in a valid determination \(RV\) tells the reporter and other participants that the report is real and in scope. That is what lets them plan the next steps, such as embargo terms and fix timing. |
|
VP-03-005 |
SHOULD | Participants SHOULD send \(RD\) when the report prioritization process ends in a deferred decision \(RD\) tells others that this participant will not work the report now. They can then adjust embargo expectations or seek another route instead of waiting. |
|
VP-03-006 |
SHOULD | Participants SHOULD send \(RA\) when the report prioritization process ends in an accept decision \(RA\) tells others that this participant has committed to work on the report, which is what they need to plan fix and publication timing. |
|
VP-03-007 |
SHOULD | Participants SHOULD send \(RC\) when the report is closed \(RC\) tells others this participant has stopped work. They stop expecting fixes or replies from it and can judge whether its exit affects the embargo. |
|
VP-03-008 |
SHOULD | A Participant that cannot process an \(R*\) message it receives SHOULD answer it with Create(ProcessingFault) (ASK-07-001), whatever its RM state. \(RE\) has no wire activity of its own (MSM-05-001).A protocol message that cannot be processed otherwise fails silently. A processing fault in any state tells the sender something went wrong, so it can correct or ask instead of assuming the message took effect. Faults are grouped by failure mode, not by state machine, so no RM-specific error message exists. For an authenticated sender, ASK-07-001 makes the fault a MUST. |
Refines: ASK-07-001 See also: MSM-05-001 — context for the reader |
VP-03-010 |
SHOULD | Recipients who receive an \(R*\) message (other than \(RS\) and \(RE\)) while in RM Start (\(q^{rm} \in S\)) SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the recipient holds no report the message could be about. A received fault is never answered with a fault (ASK-07-019). \(RE\) has no wire activity of its own (MSM-05-001).An \(R*\) message from a party the recipient has no report from means the two disagree about whether a report was sent. A fault lets the sender re-send the report. No \(RE\) message exists, because faults are grouped by failure mode (MSM-05-001). The rule is a SHOULD, not the MUST of ASK-07-001, because a recipient that understands the message can decline it with as:Reject instead (MSM-05-001). It never permits silence: a recipient that cannot process the message falls under ASK-07-001. |
Refines: ASK-07-001 See also: MSM-05-001 — context for the reader See also: ASK-07-019 — keeps a received fault out of this rule |
VP-03-011 |
SHOULD | Recipients of Create(ProcessingFault) about an \(R*\) message they sent (\(RE\)) SHOULD inquire (\(GI\)) as to the nature of the error. \(RE\) has no wire activity of its own (MSM-05-001). They do not acknowledge the fault with \(RK\) (VP-03-009).A fault says something went wrong but not always what, so asking (\(GI\)) is how the two sides find and fix the problem. No \(RK\) is needed: \(RK\) acknowledges only \(RS\) (VP-03-009). |
See also: MSM-05-001 — context for the reader See also: VP-03-009 — context for the reader |
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 |
VP-04-001 |
MUST | Every embargo that a Participant accepts MUST specify an end time (endTime).An embargo with no end time never frees participants to publish, so it can keep a vul secret indefinitely and leave users exposed. A required end time also gives every participant the same date to plan releases around. |
Refines: VP-05-001 |
VP-04-003 |
MAY | An embargo MAY be proposed An embargo is how participants agree to keep a vul private while fixes are prepared. Proposing one is how that agreement starts; without proposals participants could only disclose with no coordination window. |
|
VP-04-004 |
MAY | Once proposed, an embargo MAY be accepted or rejected An embargo binds only those who agree to it. Letting a proposal be accepted or rejected makes that agreement explicit and lets a participant refuse terms it cannot meet. |
|
VP-05-001 |
MUST | An embargo SHALL specify an unambiguous date and time as its endpoint Participants in different time zones and organizations must all stop withholding at the same moment. A date without a time, or a vague endpoint, lets them read the deadline differently and publish at different times. |
|
VP-05-002 |
SHOULD NOT | An embargo's end time SHOULD NOT fall more than one year (P1Y) after the date the embargo is accepted. Long embargoes keep users exposed to a vul that attackers may find independently. A one-year ceiling bounds that exposure. |
|
VP-05-003 |
MUST | An embargo SHALL begin at the moment it is accepted Participants need to know from what moment they are bound. Starting the embargo at acceptance leaves no gap in which a participant has agreed but is not yet bound, and no future start that could be read as permission to disclose now. |
|
VP-05-004 |
MUST | Adding Participants to an existing embargo SHALL NOT constitute release or publication so long as those Participants accept the terms of the embargo Cases often need new vendors or coordinators after an embargo is in place. If telling them counted as release, no one could be added without ending the embargo; requiring that they accept the terms keeps the information inside it. |
|
VP-05-005 |
MUST | Embargo termination SHALL NOT be construed as an obligation to publish The end of an embargo only removes the duty to withhold. Reading it as a duty to publish would force participants who are not ready, or have nothing to say, to release information. |
|
VP-05-006 |
SHOULD NOT | Embargo Participants SHOULD NOT knowingly release information about an embargoed case until all proposed embargoes have been explicitly rejected, no proposed embargo has been explicitly accepted in a timely manner, the expiration date/time of an accepted embargo has passed, or an accepted embargo has been terminated prior to expiration Releasing information while an embargo may still form or is still in force undermines the agreement other participants rely on, and can expose users before fixes exist. The listed conditions are the points at which no embargo binds the participant, so they are the only safe times to release knowingly. |
|
VP-05-007 |
SHOULD | Embargo participation SHOULD be limited to the smallest possible set of individuals and organizations needed to adequately address the vulnerability report Every additional party is another chance of a leak. Keeping participation to those needed to fix or coordinate limits that risk. |
|
VP-05-008 |
SHOULD | Embargo duration SHOULD be limited to the shortest duration possible to adequately address the vulnerability report While an embargo runs, users remain unaware of a vul that attackers may also find. Keeping it as short as the work allows limits that exposure. |
|
VP-05-009 |
SHOULD | Embargoes SHOULD be of short duration, from a few days to a few months Long embargoes raise the chance of independent discovery and exploitation while users have no information. Days to months is long enough for most fix work and short enough to bound that risk. |
|
VP-05-010 |
SHOULD | Participants stopping work on a case SHOULD notify remaining Participants of their intent to adhere to or disregard any existing embargo associated with the case Remaining participants need to know whether a departing participant will keep the information private. That tells them whether the embargo still holds or must be revisited. |
|
VP-05-011 |
SHOULD | Participants SHOULD continue to comply with any active embargoes to which they have been a party, even if they stop work on the case Information received under an embargo stays sensitive after a participant stops work. If leaving freed it to disclose, any participant could end the embargo for everyone by stepping away. |
|
VP-05-012 |
SHOULD | A Participant that leaves an Active embargo SHOULD be dropped by the CASE_MANAGER from its fan-out of further communication about the case (CM-10-004). A participant that has left an active embargo is not bound to keep new information private. Continuing to send it case updates would leak information outside the embargo. The other participants send it nothing directly (PCR-08-001, VP-18-002), so only the CASE_MANAGER's fan-out can drop it. |
Refines: CM-10-004 |
VP-05-013 |
SHOULD | Participants SHOULD consider other Participants' history of cooperation when evaluating the terms of a proposed embargo A participant's record of keeping or breaking past embargoes is the best guide to whether it will keep this one. Considering it lets participants set terms, or decline, according to the actual risk. |
|
VP-05-014 |
SHOULD NOT | Participants SHOULD NOT publish information about the vulnerability when there is an active embargo Publishing while an embargo is active breaks the agreement other participants rely on and can expose users before fixes are ready. |
|
VP-05-015 |
MAY | Additional Participants MAY be added to an existing embargo upon accepting the terms of that embargo Affected vendors and needed coordinators are often found after an embargo starts. Letting newcomers join by accepting the terms brings them in without renegotiating or ending the embargo. |
|
VP-05-016 |
MAY | Participants MAY propose a new embargo or revision to an existing embargo at any time within the constraints outlined in the Negotiating Embargoes guidance Needs change as a case develops. Allowing proposals at any time, within the negotiation guidance, lets participants adjust the embargo when they learn something new. |
|
VP-05-017 |
MAY | Participants MAY reject proposed embargo terms for any reason An embargo binds only participants who agree. A participant must be free to refuse terms it cannot keep, rather than be held to terms it never accepted. |
|
VP-05-018 |
MAY | Participants in an embargo MAY exit the embargo at any time Embargo participation is voluntary. A participant that cannot or will not keep an embargo does less harm by saying so and leaving than by staying in and breaking it. |
|
VP-05-019 |
MAY | A Participant's refusal to accept embargo terms MAY result in that Participant being left out of the CVD case entirely Sharing a vul with someone who has not agreed to keep it private puts the embargo at risk for everyone. Leaving out a participant that refuses the terms protects the others. |
|
VP-05-020 |
MAY | Participants MAY publish information about the vulnerability when there is no active embargo With no active embargo there is no agreement to withhold, and users benefit from learning about the vul. Participants need clear permission to publish then. |
|
VP-06-001 |
MUST NOT | CVD Participants MUST NOT propose or accept a new embargo negotiation when information about the vulnerability is already known to the public (\(q^{cs} \in \cdots P \cdots\)), an exploit is publicly available (\(q^{cs} \in \cdots X \cdot\)), or the vulnerability is being actively exploited (\(q^{cs} \in \cdots A\)) Once the vul is public, an exploit is public, or attacks are under way, secrecy protects no one: attackers already have what they need and defenders need the information. An embargo at that point only delays defenders. |
|
VP-06-002 |
SHOULD NOT | CVD Participants SHOULD NOT propose or accept a new embargo when the fix for a vulnerability has already been deployed (\(q^{cs} \in VFDpxa\)) Once the fix is deployed there is nothing left to prepare in private. A new embargo would only delay telling users about a vul they are already protected against. |
|
VP-06-003 |
SHOULD | A Receiver that cannot accept a Reporter's proposed embargo as proposed SHOULD propose terms it can accept (VP-06-011) rather than reject the proposal outright. Reporters hold the vul and can disclose it on their own. A counter-proposal keeps them in the coordinated process and keeps the negotiation open; an outright refusal risks the reporter publishing without coordination. The Receiver still need not accept terms it cannot keep (VP-06-010), and VP-07-004 already answers a proposal longer than its default with a counter-proposal of that default. |
Refines: VP-06-011 |
VP-06-004 |
SHOULD | Participants SHOULD explicitly accept or reject embargo proposals within the period defined in their VDP or within 14 calendar days of receipt, whichever is shorter. An open proposal leaves everyone unsure whether information may be shared. A bounded reply time, never more than 14 days, makes the outcome known soon enough for participants to plan. |
|
VP-06-004b |
SHOULD NOT | Embargo agreement or rejection SHOULD NOT be tacit. Silence can be read as either yes or no, so a tacit answer leaves participants disagreeing about whether an embargo binds them. An explicit answer gives them all the same record. |
Derives from: VP-06-004 |
VP-06-005 |
SHOULD | Participants SHOULD make reasonable attempts to retry embargo negotiations when prior proposals have been rejected or otherwise failed to achieve acceptance A case without an embargo leaves users exposed and fixes unprepared at disclosure. Retrying after a failed proposal gives coordination another chance before participants fall back to no embargo. |
|
VP-06-006 |
SHOULD | Participants SHOULD remain flexible in adjusting embargo terms as the case evolves Fix timelines, affected vendors and threat conditions change during a case. Terms that cannot adjust either expire before fixes are ready or keep holding after the need for them has passed. |
|
VP-06-007 |
MUST | Submitting a report when an embargo proposal is pending (\(q^{em} \in P\)) SHALL be construed as the Sender's acceptance of the proposed terms Sending the report while a proposal is pending shows the sender is willing to share under those terms. Treating the submission as acceptance avoids a report being shared with no embargo in force. |
|
VP-06-008 |
MAY | When \(q^{cs} \in VFdpxa\), CVD Participants MAY propose or accept a new embargo that prepares for timely publication or deployment (VP-06-008b). This is the one exception to VP-14-007. With a fix ready but not deployed, a short window can still help users by letting participants line up publication and deployment. Fix Ready otherwise ends embargo negotiation (VP-14-007), so this one purpose is named as the exception, allowed here though not required. |
Supersedes: VP-14-007 |
VP-06-008b |
SHOULD | Any embargo accepted when \(q^{cs} \in VFdpxa\) SHOULD be brief and used only to allow Participants to prepare for timely publication or deployment. At this point only release preparation remains. A long embargo would delay the deployment of a fix that already exists. |
Constrains: VP-06-008 |
VP-06-009 |
MAY | CVD Participants MAY propose or accept an embargo in all other case states (\(q^{cs} \in \cdots pxa\)) Before the fix is ready, and while nothing is public or exploited, an embargo is what gives vendors time to prepare fixes in private. This is the case the EM process exists for. |
|
VP-06-010 |
MAY | Participants MAY accept or reject any proposed embargo as they see fit An embargo binds only those who agree. Each participant knows its own ability to keep the terms and must be free to accept or refuse. |
|
VP-06-011 |
MAY | Receivers MAY propose embargo terms they find more favorable The receiver may need more or less time than the reporter suggested. A counter-proposal lets it say so while keeping the negotiation going, rather than rejecting outright. |
|
VP-06-012 |
MAY | Participants MAY withdraw their own unaccepted Proposed embargo A proposer may learn that its proposal does not fit the case after all. Withdrawing it before acceptance stops others from accepting terms the proposer has stopped supporting. |
|
VP-06-013 |
MAY | Participants MAY interpret another Participant's failure to respond to an embargo proposal in a timely manner as a rejection of that proposal A proposer cannot wait forever for an answer. Reading silence as rejection lets it move on (VP-06-014) instead of being stuck undecided while the vul stays unaddressed. |
|
VP-06-014 |
MAY | In the absence of an explicit accept or reject response from a Receiver in a timely manner, the Sender MAY proceed consistent with an EM state of None (\(q^{em} \in N\)) Without an answer, no embargo binds the receiver, so the sender may act as if none exists. That stops an unresponsive party from blocking the sender indefinitely. |
|
VP-06-015 |
MAY | In a case where the EM state is None and for which an embargo has been proposed and either explicitly or tacitly rejected, Participants MAY take any action they choose with the report, including immediate publication When negotiation has failed, there is no agreement to keep the information private. Participants then need to be free to act in users' interest, which may mean publishing. |
|
VP-06-016 |
MAY | Participants MAY withhold a report from a Recipient until an initial embargo has been accepted A recipient given the report before agreeing to an embargo is free to disclose it. Waiting for acceptance protects the information. |
|
VP-06-017 |
MAY | Participants MAY use short embargoes to cover their report validation process and subsequently revise the embargo terms pending the outcome of their validation or prioritization processes A recipient often cannot judge how much time it needs until it has validated the report. A short initial embargo protects the report meanwhile and can be revised once the needs are known. |
|
VP-07-001 |
MUST | If neither Sender nor Receiver proposes an embargo and no actor default applies, the protocol default embargo of EP-04-005 SHALL apply. A case with no embargo leaves the vul unprotected, and reaching that state only because nobody proposed terms is the least deliberate way to get there. A bounded protocol default gives every eligible case protection. |
Uses definition from: EP-04-005 |
VP-07-002 |
MUST | A Receiver's default embargo specified in its vulnerability disclosure policy SHALL be treated as an initial embargo proposal A published default tells reporters what to expect. Treating it as a proposal makes it a real negotiating position without either side having to send a first message. |
|
VP-07-003 |
MUST | If the Receiver has declared a default embargo in its vulnerability disclosure policy and the Sender proposes nothing to the contrary, the Receiver's default embargo SHALL be considered as an accepted proposal A sender that knows the receiver's published default and offers nothing else has agreed to it in effect. Treating it as accepted puts an embargo in force at once, rather than leaving the case unprotected while waiting for a formal reply. |
|
VP-07-004 |
MUST | If the Sender proposes an embargo longer than the Receiver's default, the Receiver's default SHALL be taken as accepted and the Sender's proposal taken as a proposed revision The receiver's shorter default is acceptable to both sides: the receiver published it and the sender asked for at least that much time. Accepting it puts an embargo in force at once, and the longer request stays open as a revision. |
|
VP-07-005 |
MUST | If the Sender proposes an embargo shorter than the Receiver's default, the Sender's proposal SHALL be taken as accepted and the Receiver's default taken as a proposed revision The sender's shorter proposal is acceptable to both sides: the sender asked for it and the receiver's default allows at least that much time. Accepting it puts an embargo in force at once, and the receiver's longer default stays open as a revision. |
|
VP-07-006 |
SHOULD | Report Recipients SHOULD post a default embargo as part of their Vulnerability Disclosure Policy to set expectations with potential Reporters Reporters decide how and whether to report based on what they expect. A published default tells them how long they will be asked to wait, and gives VP-07-002 a default to apply. |
|
VP-07-007 |
SHOULD | If the Sender proposes an embargo and the Receiver has no default embargo specified by policy, the Receiver SHOULD accept the Sender's proposal With no default of its own, the receiver has no stated reason to refuse. Accepting the sender's proposal puts an embargo in force at once and keeps the reporter in the coordinated process. |
|
VP-07-008 |
SHOULD | When two or more embargo proposals are open and no embargo has yet been accepted (\(q^{em} \in P\)), Participants SHOULD accept the shortest one and propose the remainder as revisions The shortest open proposal is acceptable to every proposer, since each asked for at least that much time. Accepting it puts an embargo in force at once, and treating the rest as revisions keeps the longer requests under discussion. |
|
VP-07-009 |
SHOULD | When two or more embargo revisions are open and an embargo is active (\(q^{em} \in R\)), Participants SHOULD accept or reject them individually in earliest-to-latest expiration order Open revisions with different end times interact: accepting a later one first can make an earlier one meaningless. Deciding them in expiration order lets each be judged against the terms actually in force. |
|
VP-07-010 |
MAY | Participants MAY include a default embargo as part of a published Vulnerability Disclosure Policy A published default sets reporters' expectations and lets VP-07-002 apply. Keeping it optional leaves the protocol usable by participants who negotiate case by case. |
|
VP-07-011 |
MAY | When the Receiver has no default, the Receiver MAY propose a revision after accepting the Sender's proposal Accepting the sender's proposal secures protection at once, but the receiver may need different terms once it knows more. A later revision lets it ask without leaving the case unprotected. |
|
VP-07-012 |
MAY | When the Sender proposes longer than the Receiver's default, the Receiver MAY accept or reject the proposed extension The sender's longer request is a proposed revision, not an obligation (VP-07-004). The receiver judges whether the extra time is justified. |
|
VP-07-013 |
MAY | When the Sender proposes shorter than the Receiver's default, the Sender MAY accept or reject the Receiver's proposed revision The receiver's longer default is a proposed revision (VP-07-005), and the sender is not bound by it. The sender judges whether the extra time is acceptable. |
|
VP-08-001 |
MUST | When inviting a new Participant to a case with an existing embargo, the inviting Participant SHALL propose the existing embargo to the invited Participant A newcomer must know which embargo binds the case before it sees case information. Proposing the existing embargo is how it learns the terms and is asked to keep them. |
|
VP-08-002 |
SHOULD | Participants SHOULD attempt to establish an embargo as early in the process of handling the case as possible Information shared before an embargo is in place is unprotected. Establishing one early limits how much is shared without any agreement. |
|
VP-08-003 |
SHOULD | Participants SHOULD follow consensus agreement to decide embargo terms In an MPCVD case each participant must be able to keep the terms. Terms set without broad agreement risk being broken by participants who could never meet them. |
|
VP-08-005 |
SHOULD | A newly invited Participant to a case with an existing embargo SHOULD accept the existing embargo The existing participants agreed the terms around their own work. A newcomer that accepts them joins without forcing a renegotiation, and can still propose a revision afterwards (VP-08-016). |
|
VP-08-006 |
SHOULD NOT | The inviting Participant SHOULD NOT share the vulnerability report with a newly invited Participant unless the new Participant has accepted the existing embargo Sharing the report with a participant that has not agreed to keep it private puts the whole case at risk of an uncoordinated release. |
|
VP-08-007 |
SHOULD | Participants with short default embargo policies SHOULD consider accepting longer embargoes in MPCVD cases In an MPCVD case the slowest vendor sets when all affected users can have a fix. A participant whose own policy is short may need to accept more time so others can finish. |
|
VP-08-008 |
SHOULD | Potential Participants with a longer default policy than an existing case SHOULD accept the embargo terms offered The existing terms were set around the existing participants' work. A newcomer that insists on its own longer default could hold them up, so it accepts the case's terms and seeks a revision if needed. |
|
VP-08-009 |
SHOULD | Participants in a case with an existing embargo SHOULD notify Vendors with a longer default embargo policy A vendor with a longer default policy may not be able to meet the existing embargo. Notifying it lets it start work, or ask for a revision, before the deadline instead of being surprised at publication. |
|
VP-08-010 |
SHOULD | Participants known to leak or provide vulnerability information to adversaries as a matter of policy or historical fact SHOULD be treated similar to Participants with brief disclosure policies A participant known to leak behaves, in effect, like one that will disclose early. Treating it that way keeps others from sharing more with it than they would with a party that publishes quickly. |
|
VP-08-011 |
MAY | When consensus fails to reach agreement on embargo terms, Participants MAY appoint a case lead to resolve conflicts Consensus can fail, and a case cannot wait indefinitely for terms. A case lead gives the participants a way to reach a decision. |
|
VP-08-012 |
MAY | Participants MAY engage a third-party Coordinator to act as a neutral case lead to resolve conflicts between Participants When participants disagree, a party with no product at stake can judge the dispute fairly. A third-party Coordinator offers that neutrality. |
|
VP-08-013 |
MAY | Third-party Coordinators MAY be included as Participants Coordinators bring contacts, experience and neutrality that help complex cases. Allowing them as participants lets them take part directly rather than from outside. |
|
VP-08-014 |
MAY | Other parties MAY be included as Participants when necessary and appropriate Some cases need parties beyond vendors and reporters, such as service providers, government agencies or large deployers. Allowing them when needed lets the case include everyone who can reduce harm. |
|
VP-08-015 |
MAY | The inviting Participant MAY interpret a potential Participant's default embargo policy in accordance with default acceptance strategies A potential participant's published default tells the inviter how it is likely to respond. Applying the default acceptance strategies (VP-07) lets the inviter predict the outcome and propose suitable terms. |
|
VP-08-016 |
MAY | A newly invited Participant MAY propose a revision after accepting the existing embargo Accepting first secures the newcomer's protection and the case's information. A later revision still lets it ask for terms that fit its needs. |
|
VP-08-017 |
MAY | Participants in an MPCVD case MAY delay notifying potential Participants with short default embargo policies until their policy aligns with the agreed embargo A participant whose policy would end the embargo early could publish before others are ready. Delaying its notification until its policy fits the agreed embargo reduces that risk. |
|
VP-08-018 |
MAY | After accepting an existing embargo, newly invited Participants with a longer default policy MAY propose a revision to accommodate their preferences The newcomer may need more time than the existing embargo gives. Proposing a revision after accepting lets it ask while the case stays protected. |
|
VP-08-019 |
MAY | Existing Participants MAY accept or reject a proposed revision from a newly invited Participant The existing terms were set around the existing participants' work. They must be free to decide whether a newcomer's request suits them. |
|
VP-08-020 |
MAY | Participants in a case with an existing embargo MAY choose to extend the embargo to accommodate a newly added Participant A newly added vendor may need more time to prepare a fix. Extending the embargo lets its users also be protected at publication. |
|
VP-08-021 |
MAY | Participants MAY decline to participate in future CVD cases involving parties with a history of violating previous embargoes A party that has broken embargoes before is likely to do so again. Declining to work with it protects future cases from that risk. |
|
VP-09-001 |
MUST | Embargoes SHALL terminate immediately when information about the vulnerability becomes public (\(q^{cs} \in \{\cdots P \cdots, \cdots X \cdot\}\)) Once the vul or its exploit is public, secrecy protects no one: attackers already have the information and defenders need it. Holding to the embargo would only stop participants from helping users respond. |
|
VP-09-002 |
SHOULD | Participants SHOULD be prepared with contingency plans in the event of early embargo termination Leaks, exploit publication and attacks can end an embargo at any time. A participant with no plan for that moment cannot publish advice or fixes quickly, which leaves users exposed. |
|
VP-09-003 |
SHOULD | Embargoes SHOULD terminate immediately when there is evidence that the vulnerability is being actively exploited by adversaries (\(q^{cs} \in \{\cdots A\}\)) Active exploitation means users are being harmed now and defenders need information to respond. Keeping the embargo, or delaying the teardown, would only preserve the attackers' advantage. |
|
VP-09-004 |
SHOULD | Embargoes SHOULD terminate early when there is evidence that adversaries possess exploit code for the vulnerability Adversaries holding exploit code can attack at any time. Ending the embargo early lets defenders get information and mitigations before attacks spread. |
|
VP-09-005 |
SHOULD | Participants SHOULD consider the software supply chain when determining an appropriate quorum of Vendors for release Downstream vendors build on upstream components and often cannot ship fixes until those are released. A quorum that ignores the supply chain could trigger release while many affected users still have no fix available. |
|
VP-09-006 |
MAY | Embargoes MAY terminate early when there is evidence that adversaries are aware of the technical details of the vulnerability If adversaries already know the technical details, secrecy stops buying defenders time. Participants may then end the embargo so defenders can act. |
|
VP-10-001 |
MUST | If no new embargo has been proposed or agreement has not been reached following a case merge, the earliest of the previously accepted embargo dates SHALL be adopted for the merged case Each merged case brought an embargo some participants had already agreed to. Adopting the earliest end time breaks no participant's commitment, since none agreed to withhold past its own date, until a new agreement is reached. |
|
VP-10-004 |
SHOULD | A new embargo SHOULD be proposed when any two or more CVD cases are to be merged and multiple parties have agreed to different embargo terms prior to the merger Participants of the merging cases agreed to different terms, and no single set binds all of them. A new proposal lets everyone agree to one set. |
|
VP-10-006 |
SHOULD | If any of the new cases need to renegotiate the embargo inherited from the parent case, any new embargo SHOULD be later than the inherited embargo The information in a child case is also held in its siblings. An earlier end in one child could expose the others before they are ready, so renegotiated terms should only extend the inherited date. |
|
VP-10-007 |
MAY | Participants MAY propose revisions to the embargo on a merged case as usual A merged case is still a case, and its work keeps changing. Participants need the usual way to adjust its terms. |
|
VP-10-008 |
MAY | Participants approaching a case split MAY engage a Coordinator to act as a trusted third party to help resolve and coordinate embargo dependencies for the new cases Splitting a case creates embargo dependencies between the new cases that their participants may not each see. A trusted third party who can see all of them can keep them consistent. |
|
VP-11-002 |
MUST | When the vulnerability or an exploit is public, the authority to terminate the case-level embargo SHALL belong to the Case Owner (CM-02-005). Public here means \(q^{cs} \in \{\cdots P \cdots, \cdots X \cdot\}\). Once the vul or an exploit is public, the embargo must end (VP-09-001). Separating who reports the condition (VP-11-003) from who ends the embargo keeps one authoritative decision, made by the Case Owner and recorded by the CASE_MANAGER (VP-11-011), so participants never disagree about whether the embargo still holds. |
Refines: CM-02-005 |
VP-11-003 |
MUST | Participants SHALL initiate embargo termination upon becoming aware of publicly available information about the vulnerability or its exploit code Other participants may not have seen the public information. Initiating termination makes sure the case learns of it and the embargo ends promptly. |
|
VP-11-004 |
SHOULD | Recipients SHOULD acknowledge the \(E*\) messages they receive. Once a case exists, the acknowledgment (\(EK\)) is the CASE_MANAGER's ledger entry for the message, fanned out to the participants as Announce(CaseLedgerEntry); no \(EK\) message exists (EP-09-009).An embargo message changes what participants may disclose. Acknowledging it tells the sender it arrived, so silence is not mistaken for agreement or for a lost message. Every \(E*\) message goes to the CASE_MANAGER (EP-09), and the ledger entry it commits already tells every participant the message was received; a separate \(EK\) message would only add traffic and a second acknowledgment that could disagree with the ledger. |
Uses definition from: EP-09-009 |
VP-11-005 |
SHOULD | Recipients of Create(ProcessingFault) about an \(E*\) message they sent (\(EE\)) SHOULD inquire (\(GI\)) as to the nature of the error. \(EE\) has no wire activity of its own (MSM-05-001). No \(EK\) message is sent for the fault (EP-09-009).A fault about an embargo message means the other side could not process it, so the two may now hold different embargo states. Asking what went wrong lets them find and fix the mismatch. No \(EK\) message exists to acknowledge the fault with (EP-09-009). |
Uses definition from: EP-09-009 See also: MSM-05-001 — context for the reader |
VP-11-007 |
SHOULD | Participants SHOULD initiate embargo termination upon becoming aware of attacks against an otherwise unpublished vulnerability Others in the case may not know about the attacks. Initiating termination makes sure the case learns of them and can end the embargo. |
|
VP-11-008 |
SHOULD | If early embargo termination is desired but the termination date/time is in the future, this SHOULD be achieved through an Embargo Revision Proposal and additional communication Participants must keep the existing terms until the new end time arrives. A revision proposal changes the end time through the usual agreement process, rather than leaving participants unsure whether the embargo still holds. |
|
VP-11-009 |
MAY | Participants MAY begin embargo negotiations before sending the report itself in an \(RS\) message; therefore it is not an error for an \(E*\) message to arrive while the Recipient is unaware of the report (\(q^{rm} \in S\)) Negotiating before sending the report lets the sender protect it from the moment it is shared. Treating an early \(E*\) as an error would block that. |
|
VP-11-010 |
MAY | Participants MAY reject any embargo proposals or revisions for any reason An embargo binds only those who agree. Participants must be free to refuse proposals or revisions they cannot keep. |
|
VP-12-001 |
SHOULD | Vendor Awareness (\(CV\)) messages SHOULD be sent only by Participants with direct knowledge of the notification (i.e., either the Participant who sent the report to the Vendor or the Vendor upon receipt of the report) Only those who took part in the notification know for certain that the vendor was told. Restricting \(CV\) to them stops second-hand reports from marking a vendor aware when it was not. |
Constrains: CSB-09-002 |
VP-12-002 |
SHOULD | Once attacks are observed (\(q^{cs} \in \cdots A\)), fix development SHOULD accelerate. Attacks mean users are being harmed while no fix exists. Speeding fix development shortens that harm. |
|
VP-12-002c |
SHOULD | Once attacks are observed (\(q^{cs} \in \cdots A\)), publication and deployment SHOULD follow as soon as is practical. While attacks continue, every day without published advice or a deployed fix leaves users harmed. Publishing and deploying as soon as practical shortens that harm. |
Extends: VP-12-002 |
VP-13-001 |
SHOULD | The EM process SHOULD begin when a recipient is in RM Received (\(q^{rm} \in R\)) whenever possible Received is the earliest point at which the recipient holds the report. Starting embargo work there protects the report before validation, rather than after information may already have been shared. |
|
VP-13-002 |
SHOULD NOT | Embargo Management SHOULD NOT begin in an inactive RM state (\(q^{rm} \in \{I, D, C\}\)) Invalid, Deferred and Closed mean the participant is not working on the report. Starting an embargo from those states would bind others to a timeline nobody is working toward. |
|
VP-13-003 |
SHOULD NOT | Embargo Management SHOULD NOT begin with a proposal from a Participant in RM Invalid (\(q^{rm} \in I\)) A participant that judged the report invalid does not believe there is a real vul to protect. A proposal from it would ask others to withhold information about something it does not think needs fixing. |
|
VP-13-004 |
SHOULD NOT | Embargo Management SHOULD NOT proceed from EM Proposed to EM Accepted when RM is Invalid or Closed (\(q^{rm} \in \{I, C\}\)) An Invalid or Closed participant is not working on the report. Agreeing to an embargo then would commit it to terms it has no intent to work toward. |
|
VP-13-005 |
SHOULD NOT | Participants SHOULD NOT close reports (\(q^{rm} \in \{R,I,D,A\} \xrightarrow{c} C\)) while an embargo is active (\(q^{em} \in \{A, R\}\)) A participant that closes may stop watching the case and lose track of its obligations. Keeping the report open while the embargo runs keeps the participant aware of the embargo until it ends. |
Constrains: RMB-11-004 |
VP-13-006 |
SHOULD | Reports with no further tasks SHOULD be held in Deferred or Invalid (\(q^{rm} \in \{D, I\}\)) until the embargo has terminated (\(q^{em} \in X\)) Holding the report in Deferred or Invalid keeps the participant attached to the case, and aware of the embargo, until the embargo ends, without claiming any further work. |
|
VP-13-007 |
SHOULD | Participants who choose to close a report while an embargo remains in force SHOULD communicate their intent to either continue to adhere to the embargo or terminate their compliance with it Remaining participants need to know whether someone who closed will still keep the information private. That tells them whether the embargo still holds. |
|
VP-13-009 |
MUST | A Participant's closure or deferral (\(q^{rm} \in \{C, D\}\)) of a report while an embargo remains active (\(q^{em} \in \{A, R\}\)) and while other Participants remain engaged SHALL NOT automatically terminate the embargo One participant's exit must not end protection for those still working on fixes. Otherwise any participant could end the embargo for everyone by closing or deferring. |
|
VP-13-010 |
MAY | The EM process MAY begin prior to the report being sent to a potential Participant (\(q^{rm} \in S\)) Negotiating before sending the report lets the sender protect it from the moment it is shared (VP-11-009). |
|
VP-13-011 |
MAY | Embargo Management MAY begin in any of the active RM states (\(q^{rm} \in \{R, V, A\}\)) In the active RM states the participant is working on the report. Allowing the embargo to start in any of them keeps protection timely without waiting for a later step. |
|
VP-13-012 |
MAY | Embargo Management MAY run in parallel to validation (\(q^{rm} \in \{R,I\} \xrightarrow{\{v,i\}} \{V,I\}\)) and prioritization (\(q^{rm} \in V \xrightarrow{\{a,d\}} \{A,D\}\)) activities Validation and prioritization can take time. Running embargo work alongside them protects the report while those decisions are made. |
|
VP-13-013 |
MAY | EM revision proposals and acceptance or rejection of those proposals MAY occur during any of the valid yet unclosed RM states (\(q^{rm} \in \{V, A, D\}\)) Valid, Accepted and Deferred participants still have a stake in the report. Allowing revisions then lets the embargo follow changes in the work. |
|
VP-13-014 |
MAY | Outstanding embargo negotiations (\(q^{em} \in P\)) MAY continue in RM Invalid (\(q^{rm} \in I\)) if additional information may be forthcoming to promote the report from Invalid to Valid An Invalid report may become valid with more information (VP-02-033). Keeping the negotiation open protects the report until that is known. |
|
VP-13-015 |
MAY | Embargo Management MAY proceed from EM Proposed to EM Accepted when RM is neither Invalid nor Closed (\(q^{rm} \in \{R, V, A, D\}\)) In these RM states the participant holds the report and is not done with it, so agreeing to an embargo protects real ongoing work. |
|
VP-13-016 |
MAY | Embargo Management MAY proceed from EM Proposed to EM None (\(q^{em} \in P \xrightarrow{r} N\)) when RM is Invalid or Closed An Invalid or Closed participant has no ongoing work to protect, so letting the proposal fall back to no embargo matches its position. |
|
VP-13-018 |
MAY | When a Participant receives another Participant's notice that it intends to end its compliance with an embargo, it MAY end its own compliance (VP-13-017). When one participant will stop keeping the embargo, others may judge that it has stopped protecting them. Letting them end their own compliance lets the case respond without any participant acting beyond its own authority. |
Refines: VP-13-017 |
VP-14-004 |
MUST | Participants MUST treat attacks as an event that could occur at any time and adapt their process as needed in light of available information Attacks can start before, during or after an embargo, without warning. A process that assumes they will not leaves users unprotected when they do. |
|
VP-14-005 |
SHOULD | Once a case has reached Vendor Aware (\(q^{cs} \in Vfdpxa\)) for at least one Vendor, if the EM process has not started, it SHOULD begin as soon as possible Once a vendor knows, information about the vul is spreading among parties. Starting the EM process then keeps it from spreading further without an agreement. |
|
VP-14-006 |
SHOULD | Any proposed embargo SHOULD be decided (accept or reject) soon after the first Vendor is notified An undecided proposal leaves the notified vendor unsure whether it may share the information. A quick decision gives it clear terms to work under. |
|
VP-14-007 |
SHOULD NOT | Once a case reaches Fix Ready (\(q^{cs} \in VF\cdot pxa\)), Participants SHOULD NOT start a new embargo negotiation and SHOULD reject a pending proposal. The one exception is a brief embargo to prepare for publication or deployment (VP-06-008, VP-06-008b). With a fix ready, the remaining work is release. A new or pending embargo would only delay getting the fix to users, unless it is the short window that lines that release up. |
See also: VP-06-008b — names the bound on the exception; the exception itself is VP-06-008, which records supersedes |
VP-14-008 |
SHOULD | Existing embargoes (\(q^{em} \in \{Active, Revise\}\)) when Fix Ready is reached SHOULD prepare to terminate soon With a fix ready, most of the reason for the embargo is gone. Preparing to end it lets participants release quickly. |
|
VP-14-009 |
SHOULD | Participants SHOULD accept reasonable extension proposals to allow trailing Vendors to catch up before publication when possible Publishing before all vendors are ready leaves the trailing vendors' users exposed. A reasonable extension can let everyone release together. |
|
VP-14-010 |
SHOULD NOT | Once a fix has been deployed (\(q^{cs} \in VFD\cdots\)), a Participant SHOULD NOT seek a new embargo. After the fix is deployed there is nothing left to protect by secrecy, so a new embargo only delays user awareness. |
|
VP-14-011 |
SHOULD | Exploit Publishers who are Participants in pre-public CVD cases (\(q^{cs} \in \cdots p \cdots\)) SHOULD comply with the protocol, especially when they also fulfill other roles (e.g., Reporter, Coordinator, Vendor) An Exploit Publisher in a pre-public case knows about the vul before the public. If it ignores the protocol, especially while also acting as Reporter, Coordinator or Vendor, it can make the vul public before fixes are ready. |
|
VP-14-012 |
SHOULD NOT | Exploit Publishers SHOULD NOT release exploit code while an embargo is active (\(q^{em} \in \{A, R\}\)) Released exploit code lets attackers use the vul at once. Releasing it during an embargo exposes users before fixes are ready. |
|
VP-14-014 |
MAY | In MPCVD cases where some Vendors reach Fix Ready before others, Participants MAY propose an embargo extension to allow trailing Vendors to catch up before publication When some vendors are ready earlier, publishing at once would leave the other vendors' users exposed. An extension proposal lets participants choose to give the trailing vendors time. |
|
VP-15-004 |
MAY | Vultron Protocol implementations MAY use end-to-end encryption to protect sensitive data in transit Transport encryption protects each hop only, and messages may pass through intermediaries. End-to-end encryption also protects them from those intermediaries. |
|
VP-16-001 |
MUST NOT | Vulnerability details MUST NOT appear in embargo representation data (e.g., embargo scheduling or notification messages) Embargo data, such as calendar entries and schedule notices, spreads further and with less care than case content. Keeping vul details out of it stops embargo scheduling from leaking the vul. |
|
VP-16-002 |
SHOULD | A case or vulnerability identifier SHOULD appear in embargo representation data along with an indication that it relates to an embargo expiration Recipients need to know which case an embargo date belongs to and that it is an embargo end. An identifier and an explicit embargo indication give them that without sharing any details. |
|
VP-16-003 |
SHOULD NOT | Case or vulnerability identifiers SHOULD NOT carry any information that reveals potentially sensitive details about the vulnerability Identifiers travel outside the embargo, for example in embargo notices (VP-16-002). An identifier that hints at the product or the flaw would leak information through that route. |
|
VP-18-002 |
MUST NOT | A participant MUST NOT deliver messages directly to another participant's inbox. The RK that RMB-08-003 requires an addressee of the reporter's Offer to send to the reporter is outside this rule. Direct peer-to-peer delivery bypasses the case ledger, removing the audit trail and broadcast idempotency guarantees. |
Refines: VP-18-001 |
Messages and Vocabulary
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
AKM-01-002 |
MUST NOT | Co-located actors MUST NOT communicate by reading or writing each other's local state, or by calling into each other directly. Co-located actors share a server or a process. A direct shortcut between co-located actors bypasses the inbox pipeline, so its exchanges skip validation, the addressee and entitlement gates, and the case ledger, and leave nothing a remote participant would receive. |
Derives from: PCR-01-003 |
AKM-02-001 |
MUST NOT | An Actor MUST NOT assume that a recipient has knowledge of any object that has not been explicitly included in a prior activity sent to that recipient. A recipient holds only what it has been sent. An activity that relies on an object the recipient never received cannot be processed, or is processed against a guess, so a sender must reason from what it has actually delivered to that recipient. |
|
MSM-01-004 |
MUST | Protocol shorthand RD (Report/Case Deferred) MUST have the semantic type DEFER_CASE; its AS2 wire form is Ignore(VulnerabilityCase) per VAM-03-004.A deferred report indicates the receiving actor will not engage with the case at this time. The wire representation uses Ignore(VulnerabilityCase) rather than a report-level verb because deferral is a case-participation decision, not a report-validity judgment. |
Uses definition from: VAM-03-004 |
MSM-01-005 |
MUST | Protocol shorthand RA (Report/Case Accepted) MUST have the semantic type ENGAGE_CASE; its AS2 wire form is Join(VulnerabilityCase) per VAM-03-003.Accepting a report means the receiving actor commits to engaging with the vulnerability case. The wire verb Join captures the case-participation decision, symmetric with Ignore for RD. |
Uses definition from: VAM-03-003 |
MV-03-001 |
MUST | The system MUST validate required fields based on activity type Each activity type needs some fields to have a meaning. For example, an Accept with no object accepts nothing. A check for each type refuses such an activity at the edge. Thus handlers do not need to check for a missing field that their activity type requires. |
|
MV-04-002 |
SHOULD | For Create-style activities that create sub-objects (e.g., Create(CaseParticipant)), the activity name field SHOULD be a descriptive human-readable string identifying the actor, created object ID, and context (case ID)A person who reads a log or a timeline cannot learn much from ids alone. The ids in a Create of a sub-object do not show who created which object in which case. A descriptive name lets an operator read the activity without a lookup of its ids. |
|
MV-05-002 |
MUST | The system MUST treat ActivityStreams object IDs as opaque URIs An id identifies an object and carries no other meaning, so a receiver that reads structure into it depends on how one sender mints its identifiers. ActivityStreams 2.0 and ActivityPub require an id to be an IRI (MV-05-001) but say nothing about opacity, so the rule is not inherited: it is Vultron's own, binding every implementation that receives another's identifiers. A case stub's id is the case's ID with /stub appended, and still no receiver derives the case from it (CM-11-003). |
|
VAM-01-008 |
MUST | Inbound activities represent state-change notifications, not commands; the AS2 activity type used for each semantic MUST reflect the completed state transition, not a requested action Each activity reports an act that the sender has already performed, such as an Offer it made or an Invite it sent, and not an act it asks the receiver to perform. If an activity stated a requested action, the receiver could not know whether the sender's state had changed, and two participants could record different states for the same case. A completed-action type makes each message match the change that it reports. |
|
VAM-03-003 |
MUST | ENGAGE_CASE MUST be represented as Join(VulnerabilityCase)Engage and defer are the two answers that a participant gives about its own work on a case. AS2 Join and Ignore (VAM-03-004) state those two answers, and both have the case as their object, so a receiver tells them apart by activity type alone. |
|
VAM-03-004 |
MUST | DEFER_CASE MUST be represented as Ignore(VulnerabilityCase)A defer says that the participant sets the case aside but stays in it. AS2 Ignore states that. It differs from Leave (VAM-03-006), which ends the participant's part in the case. |
|
VAM-03-005 |
MUST | ADD_REPORT_TO_CASE MUST be represented as Add(VulnerabilityReport)[target=VulnerabilityCase]A report is attached to a case that already exists, so the message is an Add with the case as its target. The target tells a receiver which case the report goes into. |
|
VM-09-001 |
MAY | A receiver MAY keep a message that it cannot parse, or whose semantics are unknown, for human or agent review. A receiver can get a message that it cannot parse or interpret, for example from a peer that runs a newer version of the protocol. If the receiver drops it, information that may matter to the case is lost and nobody can see that it arrived. Keeping it for human or agent review lets a person decide what it means. This is a MAY because the protocol does not define a meaning for such a message. |
Report, Embargo and Case State Behavior
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CSB-04-001 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM None or Exited (q^em ∈ {N, X}) receiving CP MUST transition their local CS to Public Aware (q^cs ···p·· → ···P··). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).CP is a global (participant-agnostic) CS transition. All receivers must update their own CS state. When EM is None or Exited, no embargo teardown is needed. ECA DetailsPreconditions - EM state is None or Exited; CS matches pattern ...p.. - EM state: NONE, EXITED- CS pattern: ...p..Steps 1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P 2. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is public-aware; CK discharged by the ledger commit |
Uses definition from: MSM-03-004 — CP shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-04-002 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Proposed (q^em ∈ P) receiving CP MUST transition their local CS to Public Aware. Public awareness terminates a pending embargo proposal per VP-09-001. The embargo cannot be negotiated once the information is public (VP-06-001). ECA DetailsPreconditions - EM state is Proposed; CS matches pattern ...p.. - EM state: PROPOSED- CS pattern: ...p..Steps 1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P 2. [receiver] Transition EM from PROPOSED to NONE (embargo proposal abandoned) → Receiver EM state is NONE 3. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is public-aware; EM is NONE; CK discharged by the ledger commit |
Uses definition from: MSM-03-004 — CP shorthand wire-type mapping |
CSB-04-003 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Active or Revise (q^em ∈ {A, R}) receiving CP MUST transition their local CS to Public Aware. VP-09-001 requires immediate embargo termination when public awareness occurs. The CS transition is recorded before embargo teardown begins (CSB-12-004). ECA DetailsPreconditions - EM state is Active or Revise; CS matches pattern ...p.. - EM state: ACTIVE, REVISE- CS pattern: ...p..Steps 1. [receiver] Transition local CS to Public Aware (···P··) → Receiver CS public bit set to P 2. [CASE_MANAGER] Emit ET to initiate embargo termination (CSB-04-007); a receiver that does not hold the CASE_MANAGER role emits no ET → ET queued for participants; EM begins transitioning to EXITED 3. [receiver] CASE_MANAGER commits the received CP and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is public-aware; the CASE_MANAGER has emitted ET; EM is EXITED; CK discharged by the ledger commit |
Uses definition from: MSM-03-004 — CP shorthand wire-type mapping |
CSB-04-004 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) already in CS Public Aware (q^cs ∈ ···P··) receiving a duplicate CP MUST make no CS or EM state transition. "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).Duplicate CP does not re-trigger CS or EM transitions. ECA DetailsPreconditions - CS matches pattern ...P.. - CS pattern: ...P..Steps 1. [receiver] Make no state change for the duplicate CP → CS and EM states unchanged; no CK message exists Postconditions - No state change; no CK message emitted |
Uses definition from: MSM-03-004 — CP shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-04-005 |
MUST | The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public (q^cs ∈ ···p··) and EM Proposed (q^em ∈ P) receiving CP MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001). Public awareness makes further embargo negotiation moot; the pending proposal is abandoned per VP-09-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008). |
Refines: EMB-16-001 |
CSB-05-001 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM None or Exited (q^em ∈ {N, X}) receiving CX MUST transition their local CS to both Public Aware and Exploit Public (q^cs ···px· → ···PX·). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).CX in state ···px· implies the pX→PX invariant (constraint C-15): exploit public without prior public awareness is an ephemeral state that immediately resolves to both P and X. The CS transition is atomic. ECA DetailsPreconditions - EM state is None or Exited; CS matches pattern ...px. - EM state: NONE, EXITED- CS pattern: ...px.Steps 1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set 2. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is ···PX·; CK discharged by the ledger commit |
Uses definition from: MSM-03-005 — CX shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-05-002 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Proposed (q^em ∈ P) receiving CX MUST transition their local CS to ···PX·. Exploit publication terminates a pending embargo proposal per VP-09-001. The pX→PX invariant applies (constraint C-15). ECA DetailsPreconditions - EM state is Proposed; CS matches pattern ...px. - EM state: PROPOSED- CS pattern: ...px.Steps 1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set 2. [receiver] Transition EM from PROPOSED to NONE (embargo proposal abandoned) → Receiver EM state is NONE 3. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is ···PX·; EM is NONE; CK discharged by the ledger commit |
Uses definition from: MSM-03-005 — CX shorthand wire-type mapping |
CSB-05-003 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Active or Revise (q^em ∈ {A, R}) receiving CX MUST transition their local CS to ···PX·. VP-09-001 requires immediate embargo termination when exploit publication occurs. The pX→PX invariant applies. The CS transition is recorded before teardown begins (CSB-05-010). ECA DetailsPreconditions - EM state is Active or Revise; CS matches pattern ...px. - EM state: ACTIVE, REVISE- CS pattern: ...px.Steps 1. [receiver] Transition local CS to Public Aware and Exploit Public (···PX·) → Receiver CS public bit P and exploit bit X both set 2. [CASE_MANAGER] Emit ET to initiate embargo termination (CSB-05-008); a receiver that does not hold the CASE_MANAGER role emits no ET → ET queued for participants; EM begins transitioning to EXITED 3. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is ···PX·; the CASE_MANAGER has emitted ET; EM is EXITED; CK discharged by the ledger commit |
Uses definition from: MSM-03-005 — CX shorthand wire-type mapping |
CSB-05-004 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS already public but not yet exploit-public (q^cs ∈ ···Px·) receiving CX MUST transition their local CS exploit bit to X (q^cs ···Px· → ···PX·). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).When public awareness already exists, CX transitions only the exploit bit. No new embargo teardown is triggered since the embargo should already have been terminated when P was reached. ECA DetailsPreconditions - CS matches pattern ...Px. - CS pattern: ...Px.Steps 1. [receiver] Transition local CS exploit bit to X (···PX·) → Receiver CS exploit bit X set; public bit P remains set 2. [receiver] CASE_MANAGER commits the received CX and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is ···PX·; CK discharged by the ledger commit |
Uses definition from: MSM-03-005 — CX shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-05-005 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS already exploit-public (q^cs ∈ ···PX·) receiving a duplicate CX MUST make no CS or EM state transition. "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).Duplicate CX does not re-trigger CS or EM transitions. ECA DetailsPreconditions - CS matches pattern ...PX. - CS pattern: ...PX.Steps 1. [receiver] Make no state change for the duplicate CX → CS and EM states unchanged; no CK message exists Postconditions - No state change; no CK message emitted |
Uses definition from: MSM-03-005 — CX shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-05-006 |
MUST | The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public and not yet exploit-public (q^cs ∈ ···px·) and EM Proposed (q^em ∈ P) receiving CX MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001). Exploit publication makes further embargo negotiation moot; the pending proposal is abandoned per VP-09-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008). |
Refines: EMB-16-001 |
CSB-06-004 |
MUST | A Participant in a non-Closed RM state (q^rm ∉ C) with CS already public but attacks not yet observed (q^cs ∈ ···P·a) receiving CA MUST transition their local CS attacks bit to A (q^cs ···P·a → ···P·A). "Emit CK" is discharged by the CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry); no CK message is emitted (MSM-03-008, MSM-05-002).When public awareness already exists, CA transitions only the attacks bit. The public bit is already set; no new P transition is needed. ECA DetailsPreconditions - CS matches pattern ...P.a - CS pattern: ...P.aSteps 1. [receiver] Transition local CS attacks bit to A (···P·A) → Receiver CS attacks bit A set; public bit P remains set 2. [receiver] CASE_MANAGER commits the received CA and announces the ledger entry (discharges CK) → Ledger entry committed and fanned out; no CK message exists Postconditions - Receiver CS is ···P·A; CK discharged by the ledger commit |
Uses definition from: MSM-03-006 — CA shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-06-006 |
MUST | The CASE_MANAGER in a non-Closed RM state (q^rm ∉ C) with CS not yet public and attacks not yet observed (q^cs ∈ ···p·a) and EM Proposed (q^em ∈ P) receiving CA MUST transition EM to None (q^em P → N) by abandoning each open proposal (EMB-16-001). Observed attacks make further embargo negotiation moot; the pending proposal is abandoned per VP-06-001 and EMB-16-001. The abandonment is shared EM state, so the CASE_MANAGER, which can be the Case Owner itself, makes it when it records the P/X/A status (RSH-03-001, EMB-16-001). A Participant that does not hold the role writes no EM state; its replica follows the replayed entries (EMB-16-002, EP-09-008). |
Refines: EMB-16-001 |
CSB-07-001 |
SHOULD | A Participant in a non-Closed RM state (q^rm ∉ C) that receives Create(ProcessingFault) about a CS activity it sent SHOULD inquire about the nature of the error (GI) when the fault does not say what went wrong. CE has no wire activity of its own (MSM-03-007, MSM-05-001). The receiver emits no CK for the fault (MSM-03-008).A fault about a CS activity says the sender could not process it, but not always why. Following up with GI allows the sender to explain the error and enables recovery. A fault does not trigger a CS state transition, and faults are grouped by failure mode, not by state machine, so no CE or CK message exists. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Emit GI to inquire about the nature of the error, when the fault does not say what went wrong → GI queued for sender; no CK message exists Postconditions - GI emitted; CS state unchanged |
Uses definition from: MSM-03-007 — CE shorthand wire-type mapping Uses definition from: MSM-03-008 See also: MSM-05-001 — context for the reader |
CSB-08-001 |
MAY | A Participant that receives the CASE_MANAGER's Announce(CaseLedgerEntry) for a CS activity it sent MAY treat that entry as the acknowledgment (CK) of the activity, with no further state transition and no required response. No CK message exists (MSM-03-008, MSM-05-002).The ledger entry confirms that the CASE_MANAGER received and recorded the earlier C message. As an acknowledgment it asks nothing more of the receiver. The replica acknowledges the entry itself through its unbroken hash chain (MSM-05-002).* |
Uses definition from: MSM-03-008 — CK shorthand wire-type mapping See also: MSM-05-002 — the acknowledgment by hash chain, reached through the link to MSM-03-008 |
CSB-09-001 |
SHOULD | A Vendor Participant entering CS Vendor Aware (q^cs ∈ Vfdpxa) with EM None (q^em ∈ N) SHOULD begin embargo negotiations promptly. VP-14-005 recommends starting the EM process as soon as possible once a Vendor is aware. Constraint C-32: EM SHOULD begin promptly on Vfdpxa entry when no embargo exists. ECA DetailsPreconditions - EM state is None; Participant holds the Vendor role; CS matches pattern Vfd... - EM state: NONE- Role: vendor- CS pattern: Vfd... |
Refines: VP-14-005 — Once a case has reached Vendor Aware, if the EM process has not started, it SHOULD begin as soon as possible |
CSB-09-002 |
SHOULD | A Participant entering CS Vendor Aware SHOULD emit CV to announce the transition to other case Participants. State-change notifications support shared situation awareness. CV informs other Participants that a Vendor is now aware, enabling them to coordinate embargo and fix timing accordingly. ECA DetailsPreconditions - CS matches pattern Vfd... - CS pattern: Vfd...Steps 1. [participant] Emit CV to announce Vendor Aware CS transition → CV queued for case participants Postconditions - CV emitted; other Participants informed of V transition |
Refines: VP-03-012 |
CSB-10-001 |
SHOULD NOT | A Participant entering CS Fix Ready (q^cs ∈ VFd···) SHOULD NOT start new embargo negotiations. If an embargo proposal is pending (q^em ∈ P), the Participant SHOULD reject it. The one exception is the brief publication or deployment embargo of VP-06-008. VP-14-007 discourages starting or completing new embargo negotiations once a fix is ready, and VP-06-008 names its one exception. Constraint C-34: fix readiness is late in the process for beginning embargo negotiations. ECA DetailsPreconditions - CS matches pattern VFd... - CS pattern: VFd... |
Refines: VP-14-007 — Once a case has reached Fix Ready, new embargo negotiations SHOULD NOT start and pending embargoes SHOULD be rejected, except for the VP-06-008 publication or deployment embargo See also: VP-06-008 — context for the reader |
CSB-10-002 |
SHOULD | A Participant entering CS Fix Ready SHOULD emit CF to announce the transition to other case Participants. State-change notifications support shared situation awareness. CF informs other Participants that a fix is available, enabling them to coordinate embargo extension or termination decisions. ECA DetailsPreconditions - CS matches pattern VFd... - CS pattern: VFd...Steps 1. [participant] Emit CF to announce Fix Ready CS transition → CF queued for case participants Postconditions - CF emitted; other Participants informed of F transition |
|
CSB-11-001 |
SHOULD | When a Participant enters CS Fix Deployed (q^cs ∈ VFD···) with an active embargo (q^em ∈ {A, R}), the Case Owner, or the CASE_MANAGER it delegates to, SHOULD terminate the embargo by emitting ET. VP-14-015 recommends terminating any existing embargo once the fix has been deployed. Constraint C-35: embargo termination SHOULD follow fix deployment. Ending an embargo is the Case Owner's decision, or the delegated CASE_MANAGER's, so the Participant that deploys the fix reports its CS change and does not emit ET itself (EMB-03-003, ADR-0118, EP-09-008). The Case Owner can hold the CASE_MANAGER role itself. ECA DetailsPreconditions - EM state is Active or Revise; CS matches pattern VFD... - EM state: ACTIVE, REVISE- CS pattern: VFD...Steps 1. [Case Owner or CASE_MANAGER] Emit ET to terminate the active embargo → ET queued for participants; EM begins transitioning to EXITED Postconditions - ET emitted; EM is EXITED |
Refines: VP-14-015 — By the time a fix has been deployed, any existing embargo SHOULD terminate |
CSB-12-003 |
SHOULD | A Participant entering CS Public Aware SHOULD emit CP to announce the transition to other case Participants if CP was not already the triggering event (i.e., the transition was triggered locally or by a different message type). State-change notifications support shared situation awareness. CP informs other Participants that the vulnerability is now public. This item applies when the P transition is triggered by a local event (e.g., own publication) rather than by receiving CP from another Participant. ECA DetailsPreconditions - CS matches pattern ...P.. - CS pattern: ...P..Steps 1. [participant] Emit CP to announce Public Aware CS transition → CP queued for case participants Postconditions - CP emitted; other Participants informed of P transition |
|
CSB-13-001 |
MUST | A Participant whose CS sets the exploit bit while the public bit is unset (···px·) MUST also trigger CS→P (the pX→PX invariant). It triggers CS→P before or with the exploit transition. The ephemeral state ···pX· (exploit public without public awareness) cannot exist as a stable state. Constraint C-15 requires the transition to be ···px· → ···PX·, not ···px· → ···pX· → ···PX·. Observable consequence: CX emitted from ···px· state must be accompanied by CP. The precondition uses the post-transition pattern ···pX· (X uppercase, P lowercase) since state_entered fires after the X bit is set. ECA DetailsPreconditions - CS matches pattern ...pX. - CS pattern: ...pX.Steps 1. [participant] Emit CX to announce exploit public transition → CX queued for case participants 2. [participant] Emit CP to announce public aware transition (C-15 constraint) → CP queued for case participants Postconditions - CS is ···PX·; CX and CP both emitted; pX→PX invariant satisfied |
|
CSB-14-003 |
MUST NOT | A Participant entering CS Attacks Observed MUST NOT seek new embargoes for this case. VP-06-001 prohibits seeking new embargoes once attacks have been observed. ECA DetailsPreconditions - CS matches pattern .....A - CS pattern: .....A |
Refines: VP-06-001 — Once Attacks observed, new embargoes SHALL NOT be sought |
CSB-14-004 |
SHOULD | A Participant entering CS Attacks Observed SHOULD emit CA to announce the transition to other case Participants. State-change notifications support shared situation awareness. CA informs other Participants that active exploitation has been observed, enabling them to re-evaluate embargo and disclosure decisions. VP-12-002 recommends that fix development accelerate and embargo teardown begin. ECA DetailsPreconditions - CS matches pattern .....A - CS pattern: .....ASteps 1. [participant] Emit CA to announce Attacks Observed CS transition → CA queued for case participants Postconditions - CA emitted; other Participants informed of A transition |
Refines: VP-03-012 |
DUR-01-001 |
MUST | Durations MUST be represented as ISO 8601 duration strings using the P[n]DT[n]H[n]M[n]S formatParticipants exchange durations across independent implementations, so they need a format every stack already parses the same way. ISO 8601 durations have libraries in every common language and carry their units in the string; a private format would need every implementer to agree on its grammar separately. |
|
DUR-01-003 |
MUST | Durations represent absolute elapsed time, not calendar-relative intervals; P1D means exactly 86400 seconds, with no DST or calendar adjustment impliedAn embargo ends at one instant for every participant. If P1D meant a calendar day, a duration that spans a daylight-saving change would end an hour earlier or later depending on the time zone it was computed in, and participants in different zones would disagree on when disclosure is allowed. |
|
DUR-02-001 |
MUST | Only the following units are permitted in duration strings: days (D), hours (H), minutes (M, time-part only), and seconds (S).Each of these units has a fixed length in seconds, so every implementation computes the same end time from the same string. The list is closed so that a receiver can reject anything else (DUR-04-001) rather than guess at its length. |
|
DUR-02-002 |
MUST NOT | The following units MUST NOT appear in Vultron duration strings because they introduce calendar ambiguity: years (Y), months (M, date-part), and weeks (W).A year is 365 or 366 days depending on leap year; a month is 28, 29, 30, or 31 days; a week is 5 business days or 7 calendar days depending on context. These variable lengths make duration arithmetic non-deterministic across implementations. ISO 8601 day-based durations (e.g., P90D) represent an exact number of 86400-second intervals and are unambiguous. |
|
DUR-03-001 |
SHOULD | Duration strings SHOULD be normalized to a canonical form: prefer the largest unit without remainder, except for a zero-length duration, which is written PT0S (DUR-03-003).One duration can be written several ways ( P1D, PT24H, PT1440M), so two records that hold the same value can fail a plain string comparison or show a spurious change in a diff. One preferred spelling lets readers compare strings and lets a person read the value at a glance. |
|
DUR-03-002 |
SHOULD | An embargo policy duration SHOULD use whole-day units only, where it can. Embargo terms are negotiated and compared in days, and policy ranges are read by people as well as code. A whole number of days compares against a policy range at a glance. |
|
DUR-03-003 |
SHOULD NOT | P0D SHOULD NOT be used to express a zero-length duration; prefer PT0S for explicitnessA zero duration needs one spelling so that equal values compare equal as strings. PT0S is the form a zero timedelta serializes to (DUR-05), so a zero value written and read back keeps the same spelling. |
Refines: DUR-03-001 |
DUR-04-001 |
MUST | Implementations MUST reject duration strings containing disallowed units: Y, date-part M, WA duration with a year, month or week unit has no fixed length (DUR-02-002), so two receivers that accept it can compute different embargo end dates from the same message. Rejecting it at the edge exposes the disagreement before any participant acts on its own reading. |
|
DUR-04-002 |
MUST | Implementations MUST reject malformed ISO 8601 duration strings A malformed duration that a receiver accepts with a guessed meaning sets an embargo length that nobody proposed. Rejecting it at parse time keeps the bad value out of the core and tells the sender its message was not understood. |
|
DUR-04-003 |
MUST | Implementations MUST reject empty duration strings ("P" or "PT")P and PT match the start of the grammar but state no length. A parser that read them as zero would turn a missing value into an embargo that ends the moment it starts. |
|
DUR-04-004 |
MUST | A valid duration MUST contain at least one component Each ISO 8601 component is optional on its own, so without this rule the grammar admits a duration that states no length at all. A reader would then have to guess one, and the obvious guess, zero, ends an embargo at its start. |
|
DUR-06-001 |
MUST | A duration-only embargo policy field MUST be interpreted as a relative offset from a context-specific anchor (typically case creation time) A duration alone has no position in time. Without a named anchor, two participants could apply the same policy to different start points, such as report receipt, case creation or the moment they read it, and hold different embargo end dates. |
|
DUR-06-002 |
MUST | When combined with a start timestamp, the end time is end = start + durationPlain addition with no calendar adjustment (DUR-01-003) is the one rule every implementation computes identically, so a start time and a duration give every participant the same end instant. |
|
DUR-06-003 |
MUST | A timestamp used in interval composition MUST conform to RFC 3339. A timestamp without an offset is read in each participant's local zone, so the same start time names different instants on different servers. An RFC 3339 timestamp carries its offset, so every participant reads the same instant. |
|
DUR-07-001 |
MUST | Specific embargo end times on cases MUST be declared as event intervals with unambiguous start and end timestamps, not as durations alone An embargo on a case is a commitment to a disclosure date that every participant must agree on. A duration alone depends on an anchor each participant might read differently and on when it is read, while explicit start and end timestamps name the same instants for everyone. |
|
DUR-07-002 |
SHOULD | At case creation (RM.RECEIVED), if no embargo end time is established, the case creation process SHOULD apply the actor's default embargo duration (from the actor profile) to the case creation timestamp to establish the initial embargo end time A case with no embargo end has no agreed disclosure date, and the EM process exists to lock in an embargo as early as possible. The receiving actor's published default is the terms it has already declared it will accept, so applying it at creation gives the case an embargo without a negotiation round. |
Implements: DUR-07-004 |
EMB-01-004 |
SHOULD NOT | A Participant in RM Invalid (q^rm ∈ I) SHOULD NOT propose or accept an embargo when receiving EP. VP-13-003 discourages starting embargo management from an Invalid RM state. The report has been assessed as invalid; committing to embargo terms under those conditions is premature and likely to be wasted effort. ECA DetailsPreconditions - Participant is in RM Invalid - RM state: INVALID |
Refines: VP-13-003 — SHOULD NOT begin EM with a proposal from a Participant in RM Invalid Uses definition from: MSM-02-001 — EP shorthand wire-type mapping |
EMB-01-005 |
SHOULD NOT | A Participant in an inactive RM state (q^rm ∈ {D, C}) SHOULD NOT begin embargo management by accepting an incoming EP. VP-13-002 discourages starting embargo management in inactive RM states. Deferred or Closed cases indicate the participant has deprioritized or completed their engagement; starting embargo negotiation in these states is unlikely to lead to productive coordinated disclosure. ECA DetailsPreconditions - Participant is in RM Deferred/Closed - RM state: DEFERRED, CLOSED |
Refines: VP-13-002 — SHOULD NOT begin EM in an inactive RM state Uses definition from: MSM-02-001 — EP shorthand wire-type mapping |
EMB-02-003 |
SHOULD NOT | A Participant in RM Invalid or Closed (q^rm ∈ {I, C}) SHOULD NOT allow EM to proceed from Proposed to Active upon receiving EA. VP-13-004 discourages proceeding to Active when the report has been assessed as invalid or closed. The embargo would apply to a case the participant is not actively working. ECA DetailsPreconditions - Participant is in RM Invalid/Closed - RM state: INVALID, CLOSED |
Refines: VP-13-004 — SHOULD NOT proceed from EM Proposed to EM Accepted when RM is Invalid or Closed Uses definition from: MSM-02-002 — EA shorthand wire-type mapping |
EMB-04-001 |
MUST | This rule covers a Participant in EM Revise (q^em ∈ R) whose CS is not yet public/exploit/attack (q^cs ∈ ···pxa). When it receives EJ for the last open proposal, it MUST move its EM state back to Active (q^em R → A). The CASE_MANAGER's commit of the received activity, fanned out as Announce(CaseLedgerEntry), discharges "Emit EK". No EK message is emitted (EP-09-009, MSM-02-009).EJ says that a revision proposal is rejected. A rejected revision leaves the embargo in force and the consent to it unchanged (EP-05-002), so when no other proposal is open, EM returns to Active under the terms it had. The CASE_MANAGER's commit and fan-out of the received activity tell every participant of the change, so no separate EK message is necessary (ADR-0113). ECA DetailsPreconditions - EM state is Revise; CS matches pattern ...pxa - EM state: REVISE- CS pattern: ...pxaSteps 1. [receiver] Transition EM state from REVISE back to ACTIVE → Receiver EM state is ACTIVE 2. [receiver] CASE_MANAGER commits the received EJ and announces the ledger entry (discharges EK) → Ledger entry committed and fanned out; no EK message exists Postconditions - Receiver EM state is ACTIVE (revision rejected); EK discharged by the ledger commit |
Uses definition from: MSM-02-004 — EJ shorthand wire-type mapping Uses definition from: EP-09-009 See also: MSM-02-009 — context for the reader |
EMB-08-001 |
SHOULD | A Participant that receives Create(ProcessingFault) about an embargo activity it sent SHOULD inquire about the nature of the error (GI) when the fault does not say what went wrong. EE has no wire activity of its own (MSM-02-008, MSM-05-001). The receiver emits no EK for the fault (EP-09-009).A fault report says that an embargo activity failed, but it does not always say why. An inquiry lets the sender explain the error and enables recovery. A fault report does not trigger an EM state transition, and the error is grouped by failure mode, not by state machine, so no EE or EK message exists. ECA DetailsSteps 1. [receiver] Emit GI to inquire about the nature of the error → GI queued for sender; no EK message exists Postconditions - GI emitted; EM state unchanged |
Refines: VP-11-005 — SHOULD inquire (GI) about the nature of an error reported by a fault about an E message; no EK message exists Uses definition from: MSM-02-008 — EE shorthand wire-type mapping Uses definition from: EP-09-009 See also*: MSM-05-001 — context for the reader |
EMB-09-001 |
MAY | A Participant that receives the CASE_MANAGER's Announce(CaseLedgerEntry) for an embargo activity it sent MAY treat that entry as the acknowledgment (EK) of the activity, with no further state transition and no required response. No EK message exists (EP-09-009, MSM-02-009).The ledger entry confirms that the CASE_MANAGER received and recorded the earlier E message. As an acknowledgment it carries no new decision about the embargo, so it gives the receiver nothing more to change and nothing to answer. The replica acknowledges the entry itself through its unbroken hash chain (MSM-05-002).* |
Uses definition from: MSM-02-009 — EK shorthand wire-type mapping Uses definition from: EP-09-009 |
EMB-10-001 |
MAY | A Participant entering EM Proposed MAY evaluate the proposed terms and answer the Invite with Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)), or counter-propose with EV.EM Proposed marks that embargo negotiation is underway. The participant must evaluate the proposal and eventually accept, counter, or reject to move the EM process forward. Its answer is its own consent (MSM-07-003, MSM-07-004); the Case Owner's EA or ER decides the proposal for the case (MSM-02-002, MSM-02-006). ECA DetailsPreconditions - EM state is Proposed - EM state: PROPOSED |
Refines: VP-04-004 — Once proposed, an embargo MAY be accepted or rejected Refines: VP-06-010 — Participants MAY accept or reject any proposed embargo as they see fit |
EMB-10-002 |
SHOULD NOT | A Participant in RM Invalid or Deferred or Closed (q^rm ∈ {I, D, C}) SHOULD NOT begin or continue embargo negotiations while in those inactive RM states. VP-13-002 and VP-13-003 discourage starting EM in inactive RM states. An embargo proposed while a report is invalid or deferred is unlikely to result in productive coordination. ECA DetailsPreconditions - Participant is in RM Invalid/Deferred/Closed - RM state: INVALID, DEFERRED, CLOSED |
Satisfies: VP-13-002 — SHOULD NOT begin EM in an inactive RM state Satisfies: VP-13-003 — SHOULD NOT begin EM with a proposal from a Participant in RM Invalid |
EMB-11-002 |
SHOULD | A Participant entering EM Active SHOULD maintain the embargo by not publishing information about the vulnerability until the embargo is terminated, whether on reaching its end time or early. An embargo whose end time has passed is ended by the CASE_MANAGER with the reason END_TIME_REACHED (EMB-13-003); until that termination reaches a Participant, its end time still bounds what it withholds.VP-05-014 specifies that Participants SHOULD NOT publish information about the vulnerability when there is an active embargo. Entering Active marks the formal commitment to these terms. Reaching the end time does not end the embargo by itself: the termination is a register change the CASE_MANAGER commits, so every Participant learns of it the same way (ADR-0122). ECA DetailsPreconditions - EM state is Active - EM state: ACTIVE |
Satisfies: VP-05-014 — SHOULD NOT publish information when there is an active embargo See also: EMB-13-003 — context for the reader |
EMB-11-003 |
MUST NOT | A Participant in RM Closed or Deferred (q^rm ∈ {C, D}) in EM Active while other Participants remain engaged MUST NOT automatically terminate the embargo due to their own RM closure or deferral. VP-13-009 explicitly requires that a single Participant's closure or deferral SHALL NOT automatically terminate the embargo. The embargo persists as long as other Participants remain engaged and the EM process is Active. ECA DetailsPreconditions - Participant is in RM Closed/Deferred; EM state is Active - RM state: CLOSED, DEFERRED- EM state: ACTIVE |
Refines: VP-13-009 — A Participant's closure or deferral SHALL NOT automatically terminate the embargo |
EMB-11-004 |
SHOULD | Reports with no further tasks (q^rm ∈ {D, I}) SHOULD be held in Deferred or Invalid while the embargo remains Active or Revise (q^em ∈ {A, R}) rather than being closed. VP-13-006 advises keeping the report in a non-terminal RM state until the embargo has exited. Closing early may prematurely signal disengagement from the coordinated timeline. ECA DetailsPreconditions - Participant is in RM Deferred/Invalid; EM state is Active or Revise - RM state: DEFERRED, INVALID- EM state: ACTIVE, REVISE |
Satisfies: VP-13-006 — SHOULD be held in Deferred or Invalid until embargo exits |
EMB-11-005 |
SHOULD | A Participant who intends to change their adherence stance to an active embargo SHOULD communicate that intent clearly to other Participants. VP-13-008 requires communicating changes to embargo adherence. Surprises about who is or is not honoring the embargo undermine coordinated disclosure. ECA DetailsPreconditions - EM state is Active - EM state: ACTIVE |
Satisfies: VP-13-008 — Changes to adherence intention SHOULD be communicated clearly |
EMB-12-001 |
MAY | A Participant entering EM Revise MAY evaluate the revision proposal and answer its Invite with Accept(Invite(EmbargoEvent)) or Reject(Invite(EmbargoEvent)), or counter-propose a further revision with EV.EM Revise means an active embargo has a pending revision proposal. The participant must evaluate the proposed new terms and either accept, reject, or counter-propose to move the EM process forward. Its answer is its own consent (MSM-07-003, MSM-07-004); the Case Owner's EC or EJ decides the revision for the case (MSM-02-005, MSM-02-004). ECA DetailsPreconditions - EM state is Revise - EM state: REVISE |
Refines: VP-04-005 — Once accepted, revisions MAY be proposed, which MAY be accepted or rejected |
EMB-12-002 |
MUST NOT | A Participant in RM Closed or Deferred (q^rm ∈ {C, D}) in EM Revise while other Participants remain engaged MUST NOT automatically terminate the embargo due to their own RM state. VP-13-009 applies equally in Revise state. A single Participant's closure or deferral SHALL NOT automatically terminate the embargo. The embargo remains in force even when one Participant's engagement has declined. ECA DetailsPreconditions - Participant is in RM Closed/Deferred; EM state is Revise - RM state: CLOSED, DEFERRED- EM state: REVISE |
Refines: VP-13-009 — A Participant's closure or deferral SHALL NOT automatically terminate the embargo |
EMB-12-003 |
SHOULD | A Participant who intends to change their adherence stance while an embargo is in Revise state SHOULD communicate that intent clearly to other Participants. VP-13-008 requires communicating changes to embargo adherence. This applies during revision negotiations as well as during the stable Active state. ECA DetailsPreconditions - EM state is Revise - EM state: REVISE |
Refines: VP-13-008 — Changes to adherence intention SHOULD be communicated clearly |
EMB-13-002 |
MUST NOT | A Participant in EM Exited MUST NOT seek new embargoes or accept new embargo proposals (EP) for this case when the CS state is public (q^cs ∈ ···P··), exploit-public (q^cs ∈ ····X·), or attacks-observed (q^cs ∈ ·····A). VP-06-001 prohibits seeking new embargoes once public disclosure, exploit publication, or attacks have occurred. The EXITED state after any of these events is terminal for embargo negotiations on this case. ECA DetailsPreconditions - EM state is Exited; CS matches pattern ...P.. - EM state: EXITED- CS pattern: ...P..- EM state is Exited; CS matches pattern ....X. - EM state: EXITED- CS pattern: ....X.- EM state is Exited; CS matches pattern .....A - EM state: EXITED- CS pattern: .....A |
Refines: VP-06-001 — No new embargo once public awareness, exploit publication or attacks have occurred |
EMB-19-002 |
MUST | When a case has no participants besides the CASE_MANAGER, the teardown announcement MUST be skipped rather than emitted with an empty recipient list. An activity addressed to nobody is undeliverable, and delivery discards it anyway; constructing one only adds a queue entry that can never be resolved. Skipping keeps the teardown itself unaffected, consistent with the announcement being best-effort — a notification gap MUST NOT block a teardown. |
Extends: EMB-19-001 |
EP-01-002 |
MUST | The embargo policy record MUST include the following fields: actor_id (full URI string identifying the Actor to which this policy applies), inbox (URL string of the Actor's ActivityPub inbox), preferred_duration (ISO 8601 duration string representing the Actor's preferred embargo length) A coordinator that reads a policy needs to know whose terms it states, where to send a proposal or Invite, and what length the actor prefers. Without actor_id a policy copied out of its profile cannot be attributed, without inbox the coordinator cannot reach the actor, and preferred_duration is the actor default that shortest-wins reads at case creation (EP-04-003). |
Uses definition from: DUR-01-001 — ISO 8601 duration format |
EP-01-006 |
SHOULD | When minimum_duration is declared, an Actor SHOULD reject embargo proposals shorter than that value.The minimum_duration field signals a floor below which the Actor will not accept an embargo; evaluating it prevents compatibility mismatches. |
Uses definition from: EP-01-003 |
EP-01-007 |
SHOULD | When maximum_duration is declared, an Actor SHOULD reject embargo proposals longer than that value.The maximum_duration field signals a ceiling above which the Actor will not accept an embargo; evaluating it prevents compatibility mismatches. |
Uses definition from: EP-01-003 |
EP-03-001 |
SHOULD | Before proposing an embargo or inviting an actor to join an existing embargo, the CASE_MANAGER SHOULD retrieve and evaluate the target actor's embargo policy for compatibility with the proposed embargo terms A proposal the invitee will reject costs a negotiation round and can leave the invitee outside the embargo while the round runs. Reading the published policy first lets the CASE_MANAGER choose terms the invitee has said it accepts, or know in advance that it will decline. |
|
EP-03-002 |
MUST | Compatibility evaluation MUST check that the proposed duration falls within the target actor's minimum_duration–maximum_duration range, if declaredThe declared minimum and maximum are the actor's statement of what it will accept (EP-01-006, EP-01-007). An evaluation that ignored them would report terms as compatible that the actor has already said it will reject. |
|
EP-06-001 |
MUST NOT | An idempotent retry or re-processing of a participant add-or-update MUST NOT remove or downgrade any consent row. That covers each row that has left UNINVITED for INVITED, AGREED, DECLINED or TIMED_OUT.Dropping an AGREED or DECLINED row on retry silently revokes or erases consent that was already given. The positive-path idempotency rule (don't double-add) is covered by CM-13-005; this rule covers the negative path (don't downgrade). |
Uses definition from: CM-18-001 |
RMB-01-002 |
MUST | A Vendor Participant in RM Start receiving RS that introduces a previously unknown vulnerability (q^cs ∈ vfd···) MUST transition their CS to vendor-aware (q^cs vfd··· → Vfd···) and emit CV to announce the transition. RS is the event that makes a Vendor aware of the vulnerability. The CS V-transition records this awareness and CV announces it to other Participants. ECA DetailsPreconditions - Participant is in RM Start; Participant holds the Vendor role; CS matches pattern vfd... - RM state: START- Role: vendor- CS pattern: vfd...Steps 1. [receiver] Transition RM state from START to RECEIVED → Receiver RM state is RECEIVED 2. [receiver] Transition CS from vfd··· to Vfd··· (V event) → CS vendor-aware bit set to V 3. [receiver] Emit CV to announce the CS vendor-aware transition → CV queued for case participants 4. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender Postconditions - Receiver RM state is RECEIVED; CS is vendor-aware; CV and RK emitted |
Refines: VP-03-002 — Vendor MUST transition CS to Vfd on new RS Uses definition from: MSM-01-001 — RS shorthand wire-type mapping |
RMB-01-003 |
SHOULD | A Vendor Participant already in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RS for a vulnerability they were previously unaware of (q^cs ∈ vfd···) SHOULD transition CS to Vfd··· and emit CV, even though their RM state does not change. The CS V-transition captures vendor awareness regardless of when the Vendor first receives RS. A Vendor who joins a case mid-lifecycle must still record their own awareness event. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted); Participant holds the Vendor role; CS matches pattern vfd... - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED- Role: vendor- CS pattern: vfd...Steps 1. [receiver] Transition CS from vfd··· to Vfd··· (V event) → CS vendor-aware bit set to V 2. [receiver] Emit CV to announce the CS vendor-aware transition → CV queued for case participants 3. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender Postconditions - CS is vendor-aware; CV and RK emitted; receiver RM state unchanged |
Refines: VP-03-002 — Vendor MUST transition CS to Vfd on receiving RS for new vulnerability Uses definition from: MSM-01-001 — RS shorthand wire-type mapping |
RMB-01-004 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving a duplicate RS (already Vendor-aware, q^cs ∈ V···) SHOULD emit RK to acknowledge receipt without changing RM or CS state. All R messages warrant acknowledgment unless the report is Closed. Duplicate RS does not re-trigger RM or CS transitions. ECA Details- Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Emit RK to acknowledge receipt of RS → RK queued for sender Postconditions* - RK emitted; RM and CS states unchanged |
Refines: VP-03-009 — RK acknowledgment of RS Uses definition from: MSM-01-001 — RS shorthand wire-type mapping |
RMB-02-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RI SHOULD update their record of the sender's RM state to Invalid. RI is a status announcement — it does not change the receiver's own RM state but informs them of the sender's validation result. Maintaining this record supports shared situation awareness. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Update local model of sender RM state to INVALID → Sender RM state recorded as INVALID in receiver's model Postconditions - Receiver RM state unchanged; sender's recorded RM state is INVALID |
Uses definition from: MSM-01-002 — RI shorthand wire-type mapping |
RMB-02-002 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RI SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RI could be about. RE has no wire activity of its own (MSM-05-001).Receiving any R message other than RS while in RM Start means the sender believes the receiver is coordinating a report the receiver has no knowledge of. A processing fault is the protocol's error response (VP-03-010). ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-002 — RI shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-03-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RV SHOULD update their record of the sender's RM state to Valid. RV announces the sender's validation result. Maintaining this record supports shared situation awareness across Participants. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Update local model of sender RM state to VALID → Sender RM state recorded as VALID in receiver's model Postconditions - Receiver RM state unchanged; sender's recorded RM state is VALID |
Uses definition from: MSM-01-003 — RV shorthand wire-type mapping |
RMB-03-002 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RV SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RV could be about. RE has no wire activity of its own (MSM-05-001).Receiving any R message other than RS while in RM Start is an error condition indicating the sender has a mistaken expectation about the receiver's case knowledge. ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-003 — RV shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-04-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RD SHOULD update their record of the sender's RM state to Deferred. RD announces the sender's deferral decision. Maintaining this record supports shared situation awareness and coordination planning. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Update local model of sender RM state to DEFERRED → Sender RM state recorded as DEFERRED in receiver's model Postconditions - Receiver RM state unchanged; sender's recorded RM state is DEFERRED |
Uses definition from: MSM-01-004 — RD shorthand wire-type mapping |
RMB-04-002 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RD SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RD could be about. RE has no wire activity of its own (MSM-05-001).Receiving any R message other than RS while in RM Start is an error condition. ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-004 — RD shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-05-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RA SHOULD update their record of the sender's RM state to Accepted. RA announces the sender's commitment to work the report. Recording this supports shared situation awareness and helps coordinate timing of follow-on actions such as embargo proposals. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Update local model of sender RM state to ACCEPTED → Sender RM state recorded as ACCEPTED in receiver's model Postconditions - Receiver RM state unchanged; sender's recorded RM state is ACCEPTED |
Uses definition from: MSM-01-005 — RA shorthand wire-type mapping |
RMB-05-002 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RA SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RA could be about. RE has no wire activity of its own (MSM-05-001).Receiving any R message other than RS while in RM Start is an error condition indicating the sender has a mistaken expectation about the receiver's case knowledge. ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-005 — RA shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-06-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RC SHOULD update their record of the sender's RM state to Closed. RC announces that the sender has completed their work on the report. Maintaining this record supports shared situation awareness and potential auto-close evaluation. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Update local model of sender RM state to CLOSED → Sender RM state recorded as CLOSED in receiver's model Postconditions - Receiver RM state unchanged; sender's recorded RM state is CLOSED |
Uses definition from: MSM-01-006 — RC shorthand wire-type mapping |
RMB-06-002 |
MAY | After receiving RC from all other active Participants, a Participant MAY evaluate whether local closure criteria are satisfied and, if so, initiate closure of their own RM state. When all other parties have closed, remaining open is often unnecessary. This auto-close judgment is based on local policy and current EM state. ECA DetailsPreconditions - Participant is in RM Received/Invalid/Deferred/Accepted - RM state: RECEIVED, INVALID, DEFERRED, ACCEPTED |
Uses definition from: MSM-01-006 — RC shorthand wire-type mapping |
RMB-06-003 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RC SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RC could be about. RE has no wire activity of its own (MSM-05-001).Receiving any R message other than RS while in RM Start is an error condition. ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-006 — RC shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-07-001 |
SHOULD | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) that receives Create(ProcessingFault) about an RM activity it sent SHOULD inquire (GI) about the nature of the error when the fault does not say what went wrong. RE has no wire activity of its own (MSM-05-001).The fault says the sender could not process an RM activity, but not always why. GI opens a dialogue to resolve the problem. No RK is sent: RK acknowledges only a report submission and never goes to the CASE_MANAGER (RMB-08-003). ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTEDSteps 1. [receiver] Emit GI to inquire about the nature of the error, when the fault does not say what went wrong → GI queued for sender Postconditions - GI emitted; receiver RM state unchanged |
Refines: VP-03-011 — Inquire about the error with GI; RK is not sent (RMB-08-003) Uses definition from: MSM-01-007 — RE shorthand wire-type mapping See also: MSM-05-001 — context for the reader |
RMB-08-001 |
MAY | A Participant in an active RM state (q^rm ∈ {R,I,V,D,A}) receiving RK MAY take no further action; RK is an acknowledgment and requires no response. RK closes the acknowledgment loop. Emitting RK in response to RK would create an infinite acknowledgment chain. The protocol specifies no mandatory response to RK from an active-state receiver. ECA DetailsPreconditions - Participant is in an active RM state (Received/Invalid/Valid/Deferred/Accepted) - RM state: RECEIVED, INVALID, VALID, DEFERRED, ACCEPTED |
Derives from: VP-03-009 — RK itself is never acknowledged with another RK Uses definition from: MSM-01-008 — RK shorthand wire-type mapping |
RMB-08-002 |
SHOULD | A Participant in RM Start (q^rm ∈ S) receiving RK SHOULD answer it with Create(ProcessingFault) (ASK-07-001). The fault tells the sender that the receiver holds no report the RK could be about. RE has no wire activity of its own (MSM-05-001).RK arriving in START means the sender believes the receiver has already acknowledged a message the receiver has never seen. A processing fault is the protocol's error response for any R message received while in RM Start per VP-03-010. ECA Details- Participant is in RM Start - RM state: STARTSteps 1. [receiver] Emit Create(ProcessingFault) to signal the unexpected message → ProcessingFault queued for sender; no RE message exists Postconditions* - ProcessingFault emitted; no RK in reply to RK (RMB-08-001); receiver RM state unchanged (START) |
Refines: VP-03-010 — Processing fault when R received while in RM Start Uses definition from: MSM-01-008 — RK shorthand wire-type mapping See also: ASK-07-001 — the Create(ProcessingFault) clause, reached through the link to VP-03-010See also*: MSM-05-001 — context for the reader |
RMB-09-002 |
MAY | A Participant entering RM Received MAY temporarily hold the report pending additional information if the initial validation cannot be completed with available data. Reports may arrive with insufficient detail for immediate validation. Holding in Received preserves the option to revalidate when the Reporter provides more information. ECA DetailsPreconditions - Participant is in RM Received - RM state: RECEIVED |
Refines: VP-02-012 — MAY temporarily hold reports pending additional information |
RMB-10-002 |
MUST NOT | A Participant in RM Valid MUST NOT close the report directly from the Valid state (q^rm V → C) without first transitioning through Accepted or Deferred (constraint C-03). Closing directly from Valid skips the mandatory prioritization step. Reports with no further action should be Deferred first and then Closed, preserving the prioritization record. ECA DetailsPreconditions - Participant is in RM Valid - RM state: VALID |
Refines: VP-02-004 — Participants MUST NOT close cases from the Valid state |
RMB-10-003 |
SHOULD | A Participant entering RM Valid SHOULD emit RV to announce the validation result to other Participants. State-change notifications support shared situation awareness. Other Participants tracking this report depend on RV to update their model of the sender's RM state. ECA DetailsPreconditions - Participant is in RM Valid - RM state: VALIDSteps 1. [participant] Emit RV to announce RM Valid transition → RV queued for case participants Postconditions - RV emitted; other Participants informed of Valid transition |
Refines: VP-03-004 — SHOULD send RV when validation ends in valid determination Refines: VP-03-012 — SHOULD send a message for each RM state transition |
RMB-10-004 |
SHOULD | A Participant entering RM Valid SHOULD create or update a case object to track the report's progress through the CVD process. Valid reports represent confirmed vulnerability coordination work. A case object enables participant management, embargo coordination, and state tracking across all involved parties. ECA DetailsPreconditions - Participant is in RM Valid - RM state: VALID |
Refines: VP-02-015 — SHOULD create a case for reports entering the Valid state |
RMB-11-004 |
MAY | A Participant in RM Invalid MAY close the report if no further action is expected and no active embargo is in force (q^em ∉ {A,R}). Invalid reports with no prospect of revalidation should eventually be closed. Active embargo constraints on closure still apply. ECA DetailsPreconditions - Participant is in RM Invalid - RM state: INVALID |
Refines: VP-02-035 — Participants MAY close Invalid reports |
RMB-12-002 |
SHOULD | A Participant in RM Deferred SHOULD monitor for new information (updated threat intelligence, exploitation activity, or vendor progress) that could justify reprioritization toward Accepted. Deferred does not mean permanently shelved. Changed conditions may restore the urgency needed to resume active work on the report. ECA DetailsPreconditions - Participant is in RM Deferred - RM state: DEFERRED |
|
RMB-12-003 |
MAY | A Participant in RM Deferred MAY set a policy timer to automatically move the report to Closed after a defined period of inactivity. Indefinitely deferred reports accumulate as open coordination debt. A timer enforces eventual cleanup consistent with local policy without requiring manual review of every dormant case. ECA DetailsPreconditions - Participant is in RM Deferred - RM state: DEFERRED |
Refines: VP-02-031 — MAY set a policy timer on Deferred reports |
RMB-13-001 |
MUST | A Participant MUST be in RM Accepted (q^rm ∈ A) before sending RS to another Participant to initiate CVD coordination (constraint C-04). Sending RS from any other RM state is prohibited. Sending RS from a non-Accepted state would initiate coordination before the sender has committed to working the report. Accepted represents the sender's confirmed engagement and readiness to coordinate. ECA DetailsPreconditions - Participant is in RM Accepted - RM state: ACCEPTED |
Refines: VP-03-001 — MUST be in RM Accepted to send RS Refines: VP-02-003 — Participants initiating CVD with others MUST do so from Accepted state |
RMB-13-003 |
SHOULD | A Participant in RM Accepted SHOULD perform active work on the report (e.g., fix development, remediation guidance, coordination with other Participants via RS). Accepted is the active engagement state. Entering Accepted without performing work reduces coordination effectiveness and may violate implicitly agreed timelines within an active embargo. ECA DetailsPreconditions - Participant is in RM Accepted - RM state: ACCEPTED |
|
RMB-14-003 |
SHOULD NOT | A Participant SHOULD NOT close a report (q^rm ∈ {R,I,D,A} → C) while an active embargo is in force (q^em ∈ {A,R}) unless they first communicate their closure intent, and whether their Embargo Consent continues, to other Participants. Closing while an embargo is active may signal withdrawal from the coordinated timeline without proper notification, potentially undermining the agreed disclosure date for all parties. ECA DetailsPreconditions - Participant is in RM Received/Invalid/Deferred/Accepted; EM state is Active or Revise - RM state: RECEIVED, INVALID, DEFERRED, ACCEPTED- EM state: ACTIVE, REVISE |
Refines: VP-13-007 — SHOULD communicate intent to adhere or terminate compliance when closing during an active embargo Supersedes: VP-13-005 |
SM-10-001 |
MUST | A message that moves a participant-specific machine (RM, VF or D) MUST move it for the participant whose state the message's occasion declares (ADR-0162). For a participant-status message, that participant is the sender (CM-04-001, CM-04-002). For a report's receipt, it is the receiver, whose own RM moves to RM.RECEIVED.RM and VFD state describe the progress of one participant, so each participant's RM and VFD state evolves independently. A status message reports its sender's state; other messages move the receiver's own. No rule on the machine alone tells which, so each occasion declares it. A record on the wrong participant would give it progress it did not make. |
|
SM-10-002 |
MUST | EM and PXA state transitions MUST update the shared CaseStatus record for the associated VulnerabilityCase. These axes are participant-agnostic: a single shared value covers all participants in the case.EM and PXA state are facts about the case, not about one participant (CM-04-003, CM-04-004). One shared record gives every participant the same embargo state and the same public state. Separate copies for each participant could disagree on whether an embargo is in force or whether the vul is public. |
Case Management
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CM-01-001 |
MUST | Each actor MUST have an isolated protocol state domain Each actor is a separate party, with its own view of the case and its own authority over its state. If the records of one actor can change what another actor reads, a fault or a hostile peer in a shared deployment can change the case history of another party. Then no actor can trust its own copy. |
|
CM-01-002 |
MUST | Each actor's RM state MUST be maintained independently per case RM is a process for each participant. Each participant receives, validates, accepts, defers and closes a report on its own schedule (CM-03-002). One RM state for each actor in each case lets an actor be at different RM stages in different cases. It also stops the progress of one actor from counting as the progress of another actor. |
|
CM-02-003 |
MUST | CASE_MANAGER MUST persist until the associated VulnerabilityCase is closed The authority for a case must be clear for as long as the case accepts changes. If the CASE_MANAGER role stops before the case closes, messages that need its decision have no valid recipient. Then the case cannot close in the correct sequence. |
|
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. |
|
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-003 |
MUST | A shared EM state MUST be tracked at the case level in the case's CaseStatus, to represent the collective embargo agreementAn embargo binds every participant in the case. Thus, whether an embargo is proposed, active or ended is one fact for the whole case. One case-level record gives every participant the same answer. The consent rows keep each participant's agreement separately (CM-10-001). |
Implements: VP-04-002 |
CM-03-004 |
MUST | CS (PXA sub-state) MUST be participant-agnostic (shared per case) Public awareness, exploit publication and attacks in the wild are facts about the world, not about one participant. When the vulnerability is public, it is public for all participants. A copy for each participant can only disagree with the facts. |
|
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-03-007 |
MUST | RM state transitions MUST use the established protocol activity types without introducing new activity types for reverse transitions Keeps the RM symbol set minimal and produces clean audit histories; Undo conflates historical negation with a new forward transition |
|
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-003 |
MUST | When the Case Owner accepts an embargo, the CASE_MANAGER MUST activate it in the case's embargo register, from which the case-level EM state derives (ADR-0122). Every other replica takes that state from the CASE_MANAGER's ledger (RSH-08-003). The shared embargo binds the case only when the Case Owner accepts it (CM-02-005). A case-level record of that acceptance puts the embargo in force for all participants at the same time. Only the CASE_MANAGER writes canonical case state (ADR-0108), and the EM state is derived from the append-only register, with CaseStatus.em only a stamped copy (ADR-0122). The acceptances of other participants stay in their own consent rows (CM-04-008). |
See also: RSH-08-003 — context for the reader |
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 |
CM-04-006 |
MUST NOT | A participant-specific transition (RM or VFD) MUST NOT change any case-level (participant-agnostic) state (EM or PXA). Participant-specific state and case-level state are separate by design (CM-03-002 through CM-03-005). If an RM or VFD transition of one participant wrote across this boundary, it could change the shared embargo or public state. |
Satisfies: VP-13-009 |
CM-04-007 |
MUST | RM transition validation MUST treat RM.CLOSED as terminal before it applies any same-state no-op shortcut.If the validator checks for equality first, a duplicate close retry can flow into the later append and broadcast paths as a fresh state change. |
|
CM-04-008 |
MUST | When processing an EM state transition and the accepting actor is any participant other than the Case Owner, the receiver MUST update only that participant's own consent row for the accepted embargo. Non-owner participants do not advance the shared EM state; their individual acceptance updates only their own consent record. |
|
CM-05-002 |
MUST NOT | A VulnerabilityCase MUST NOT exist without a reference to at least one VulnerabilityReport.A case exists to coordinate the response to a reported vulnerability. A case with no report has nothing to coordinate and gives participants nothing to act on. Also, a participant that joins later reads the report to learn what the case is about. |
|
CM-05-003 |
SHOULD | A VulnerabilityCase SHOULD reference at least one VulnerabilityItem before closureA VulnerabilityItem identifies the vulnerability outside the case, for example with a CVE ID. If a case closes without one, the outcome is difficult to find and to cross-reference. Some cases close without one for a good reason, thus the rule is a SHOULD. |
|
CM-05-006 |
MAY | One report MAY describe several vulnerabilities. Reports and vulnerabilities do not always map one to one. One finder can report several flaws together. |
|
CM-05-007 |
MAY | Multiple CaseReference objects MAY arise from a single case (e.g., coordinated simultaneous disclosure by multiple vendors)When several vendors fix the same vulnerability, each vendor usually publishes its own advisory. The case must record all of these advisories, not only one. |
|
CM-05-011 |
SHOULD | CaseReference objects SHOULD include a name field containing a human-readable title.A human-readable title makes references easier to identify in case summaries and reports. |
|
CM-06-004 |
MUST | Participants MUST authenticate case update notifications before accepting them as authoritative Participants accept an update as authoritative only when it comes from the CASE_MANAGER (CM-06-002). Without authentication, any party can claim to be the CASE_MANAGER and send false case state, for example an embargo that it says is lifted. |
|
CM-09-001 |
SHOULD | The system SHOULD support a RedactedVulnerabilityCase type for sharing case information with invited-but-not-yet-accepted participantsAn invitee has not yet agreed to the embargo. Thus, it must learn only enough about the case to decide whether to join. A redacted view gives it this information and does not disclose case details that it has no obligation to protect yet. |
|
CM-09-002 |
MUST | The ID of a RedactedVulnerabilityCase MUST be cryptographically unrelated to the full VulnerabilityCase ID. The prototype case stub (CM-11-013) is not a RedactedVulnerabilityCase, and this requirement does not apply to it.Prevents an attacker who obtains a redacted case ID from inferring the full case ID |
See also: CM-11-013 — context for the reader |
CM-09-003 |
MUST | Each invitee MUST receive a distinct RedactedVulnerabilityCase IDPrevents cross-correlation of redacted IDs to infer participant list size or identities |
|
CM-10-002 |
MUST | Embargo acceptances MUST be timestamped by the CASE_MANAGER at the time of receipt, not using the participant's claimed timestamp The CASE_MANAGER applies the only trusted timestamp; the participant's reported time cannot be verified |
Refines: CM-02-009 |
CM-12-002 |
MUST | At case creation, the system MUST create two initial CaseParticipant records in the order defined by CM-14-001At receipt, the case knows two parties: the Case Owner and the reporter. Each party needs its own RM state (CM-01-002). Thus each party needs a record before the case records anything else about it. The CM-14-001 order makes sure that an existing participant creates the embargo, and that the reporter has the case before any entry about the case arrives. |
Uses definition from: CM-14-001 |
CM-12-004 |
MUST | A default embargo MUST be initialized at case creation (RM.RECEIVED) following the sequence in CM-14-001 whenever the case is embargo-eligible — from the receiver's actor default where one is configured, and otherwise from the protocol default of EP-04-005 If a case has no embargo, the reporter's information has no protection when another party joins. The receiver initializes the default embargo at RM.RECEIVED, before it adds any other participant. Thus every later participant joins under the embargo (CM-14-010). The protocol default makes sure that a receiver with no configured policy also gets an embargo with a limit (EP-04-019, ADR-0096). |
Refines: DUR-07-002 — which now applies at case receipt Uses definition from: CM-14-001 Depends on: EP-04-005 |
CM-14-001 |
MUST | The case initialization sequence MUST execute exactly 6 ordered steps (CM-14-008 through CM-14-013) before the case is considered fully initialized. No step may be omitted or reordered. Step CM-14-009 precedes CM-14-010 so that the embargo is always created by a participant (the Case Owner). The Create(VulnerabilityCase) notification in CM-14-011 is flushed before the reporter is added in CM-14-012 so each recipient of that Create holds the case object before any subsequent Announce(CaseLedgerEntry) fan-out that references it. |
|
CM-14-004 |
MUST | The Create(VulnerabilityCase) notification MUST be queued and the outbox flushed before the reporter is added as a CaseParticipant in step 5 of CM-14-001The reporter's system must receive and store the case object before any Announce(CaseLedgerEntry) fan-out that lists them as a participant. Reversing this order causes "case not found" errors on the reporter side when the log entry arrives referencing a case the reporter has not yet seen. |
Derives from: CM-14-001 Uses definition from: CBT-01-001 |
CM-14-008 |
MUST | Step 1 of the case initialization sequence MUST create the VulnerabilityCase with the receiving actor set as attributed_to.Creating the case object first establishes the anchor to which all subsequent initialization steps (participants, embargo, ledger) are attached. |
Part of: CM-14-001 |
CM-14-010 |
MUST | Step 3 of the case initialization sequence MUST initialize the default embargo to EM.ACTIVE and seed the Case Owner as a signatory whenever the case is embargo-eligible, using the actor default where one is configured and the EP-04-005 protocol default otherwise.The embargo must be in place before any participant other than the Case Owner is added, so that all subsequent participants are subject to the embargo from the moment they join. |
Part of: CM-14-001 Depends on: EP-04-005 |
CM-14-013 |
MUST | Step 6 of the case initialization sequence MUST commit a case ledger entry, triggering Announce(CaseLedgerEntry) fan-out to all participants.The ledger entry commits the completed initialization as a single protocol-significant event and notifies all participants atomically. |
Part of: CM-14-001 |
CM-16-002 |
MUST | When the CASE_MANAGER receives Offer(Actor)[target=VulnerabilityCase], it MUST commit a CaseLedgerEntry for the received Offer and fan out the entry to every active participant (CM-10-004) BEFORE taking any downstream action.Ledger entries record events that have already occurred; pre-committing a decision before communicating it is not permitted (CLP-10-006 commit ordering). |
Refines: CLP-10-006 Uses definition from: CM-10-004 |
CM-18-004 |
MUST NOT | A participant's consent row MUST NOT move from AGREED to INVITED directly. The only paths back to INVITED from a resolved row are DECLINED → INVITED (re-invite after explicit decline) and TIMED_OUT → INVITED (re-invite after an unanswered invitation timed out); a participant that has lapsed is re-invited on its row for the new embargo (an INVITED row for it), which leaves its AGREED row for the old embargo alone.Consent already given cannot be withdrawn by re-inviting the participant. A signatory to the active embargo is bound by it; only replacing that embargo with longer terms (which lapses the participant by derivation — ADR-0093, ADR-0122) or the participant's own withdrawal ( DECLINE) ends that position. |
Derives from: CM-18-003 |
CM-20-001 |
MUST | A Coordinator invited to a case as a regular participant MUST hold COORDINATOR in their case_roles list.CASE_OWNER confers case administration authority (CM-02-001, CM-02-004, CM-02-005). CASE_MANAGER is a distinct role: it grants single-writer authority over the canonical ledger (CLP-09) and is held by the case-creating actor enacting CVDRole.CASE_MANAGER, which SHOULD also carry CVDRole.COORDINATOR (CBT-01-015). It is not conferred merely for being invited as a facilitation participant, so a Coordinator invited as a regular participant holds neither CASE_OWNER nor CASE_MANAGER. |
|
CM-20-002 |
MUST | When the Case Owner approves a Coordinator suggested through the Offer(Actor)[target=VulnerabilityCase] path (CM-16), the Coordinator's roles MUST include COORDINATOR.Role assignments at invite time must reflect the invited actor's actual function in the case, not its organizational identity. A Coordinator invited to facilitate holds the COORDINATOR role, so role checks find it as one. |
Refines: CM-20-001 |
CM-20-003 |
MUST | A Coordinator participant that holds COORDINATOR without CASE_MANAGER MUST route its Offer(Actor)[target=VulnerabilityCase] suggestion to add another actor through the CASE_MANAGER inbox, per ADR-0026 (CM-16-001).A Coordinator-as-participant should be able to exercise their facilitation role (suggesting additional vendors) without requiring ownership transfer. The CASE_MANAGER-routed suggest flow (ADR-0026) already provides this: the Coordinator sends Offer(Actor)[target=VulnerabilityCase] to the CASE_MANAGER, which records and forwards it to the Case Owner for approval. |
Refines: CM-16-001 |
CM-20-004 |
MUST NOT | A Coordinator invited to a case as a regular participant MUST NOT hold the CASE_MANAGER role in its case roles.CVDRole.CASE_MANAGER grants single-writer authority over the canonical ledger and is held by the actor that created the case and enacts that role (CBT-01-014, ADR-0088). It MUST NOT be conferred on an organizational or human actor invited to the case as a regular facilitation participant. |
Extends: CM-20-001 Refines: CM-20-005 |
CM-20-005 |
MUST NOT | The CASE_MANAGER role MUST NOT be assigned to any organizational or human participant joining a case as a facilitation actor rather than as the actor enacting the CASE_MANAGER role (CM-02-011).CVDRole.CASE_MANAGER grants single-writer authority over the canonical ledger (CLP-09). Conferring it on a participant invited for facilitation would let them author ledger entries that only the actor enacting CVDRole.CASE_MANAGER is authorized to write. |
Uses definition from: CM-02-011 |
CM-21-009 |
MUST | When an ownership transfer is processed, the previous owner MUST remain a participant in the case. Ownership transfer is not case departure. The previous owner has institutional knowledge of the case and continues to participate; only their administrative authority is transferred. |
Extends: CM-21-003 |
CM-23-006 |
MUST | For the CASE_MANAGER's CaseParticipant, RM.RECEIVED MUST denote that a CaseProposal has been received and is being evaluated.The RM state machine models a lifecycle that applies to any actor processing a case, but its transition labels map to case-level events for the coordinator rather than to report-validation events as for other participants. See ADR-0051. |
Refines: CM-23-005 |
CM-23-008 |
MUST | For the CASE_MANAGER's CaseParticipant, RM.VALID MUST denote that the CaseProposal is correctly formatted and actionable by this CASE_MANAGER, and that case creation has begun.RM.VALID is the CASE_MANAGER's signal that the proposal passed structural validation and that initialization is in progress; it distinguishes a validated-but-incomplete case from one still under evaluation. See ADR-0051. |
Refines: CM-23-005 |
CM-23-009 |
MUST | For the CASE_MANAGER's CaseParticipant, RM.ACCEPTED MUST denote that the case has been successfully created and is being coordinated.RM.ACCEPTED marks the end of the initialization phase and the start of active coordination; it is the CASE_MANAGER's counterpart to a reporter's or vendor's RM.ACCEPTED (engagement decision). See ADR-0051. |
Refines: CM-23-005 |
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 |
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-003 |
MUST | An Observer MUST receive full case content once it is an active participant (CM-10-004). That check is the sole gate on case content for an Observer. No additional or reduced delivery tier applies. An Observer that accepts the stub Invite consents to the active embargo (CM-11-001). The absence of a remediation function does not change what the Observer is entitled to receive once it is active. Introducing a separate reduced delivery tier for Observers is deferred: notes/selective-disclosure.md describes the potential future mechanism but it is not yet implemented. |
Uses definition from: CM-10-004 |
CM-25-004 |
SHOULD | After accepting a case invitation and receiving the full case replica, an Observer SHOULD run the standard RM triage cycle (CM-11-002): RM.VALID or RM.INVALID, then RM.ACCEPTED or RM.DEFERRED. For an Observer, RM.ACCEPTED means "I am actively engaged with / monitoring this case" — it does NOT imply commitment to develop or deploy a fix. The RM triage cycle represents an Observer's assessment of whether the case is relevant to them and whether they intend to remain engaged. An Observer that determines the case is outside their scope should transition to RM.INVALID or RM.DEFERRED, not silently stay at RM.RECEIVED. This preserves the RM machine's semantics as a participation-intent signal. |
Refines: CM-11-002 |
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 |
CM-25-007 |
MUST NOT | An Observer invitation MUST NOT carry an empty case-roles list: an empty list names no role, so the invitee's participant record would violate the CM-16-003 non-empty invariant.[] provides no role information to the CASE_MANAGER's participant-creation path on the stub Invite (CM-11-006), producing a participant record that violates the non-empty role invariant enforced by CM-16-003. |
Derives from: CM-25-006 See also: CM-16-003 — context for the reader |
CM-28-002 |
MUST | When an Invite(EmbargoEvent) carries an end_time, that value MUST be authoritative for the invitation's expiry, superseding the receiver's local policy window. The resulting deadline stays subject to the EP-07-006 ceiling.An explicit wire value lets both parties calculate the same lapse time from the same field, with no more messages. A window that only the receiver knows does not let the two parties agree if an invitation is still open. See ADR-0065. |
Supersedes: CM-18-023 Refines: EP-07-006 |
CP-01-006 |
MAY | A CaseProposal MAY include an optional summary field with a human-readable description of the proposal.A person who reviews proposals at the Case Actor Service may need to know why the report receiver asks for a case. A short description gives that context. The field is optional because the proposal is complete without it. |
Case Ledger and Replication
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
CBT-02-002 |
MUST NOT | Transport authentication or encrypted direct messaging alone MUST NOT be treated as establishing authority to trust a previously unknown CASE_MANAGER; the explicit bootstrap trust handoff is required. Transport authentication shows which actor sent a message. It does not show that the actor may manage the case. Only a Trust Anchor the receiver wrote, from a relationship it had before the case arrived, ties the case to a CASE_MANAGER (CBT-01-005, CBT-04-001). |
|
CBT-03-002 |
MUST NOT | A pre-bootstrap CASE_MANAGER message MUST NOT update local case state before the corresponding trust-establishing bootstrap message has been validated. Before the bootstrap is validated, the receiver cannot know that the sender is the CASE_MANAGER. A state change from that message can come from any actor, and the receiver would then hold case state that no trusted source sent. |
Refines: PCR-06-003 |
CLP-01-001 |
MUST | Non-CASE_MANAGER activities that participate in a report, proto-case, or case workflow MUST be treated as participant assertions awaiting CASE_MANAGER processing A participant can only claim that it did something. Only the CASE_MANAGER can make that claim part of the shared case history. If a receiver treats a participant's activity as settled fact, two receivers can disagree about the same case. Treating it as an assertion keeps one place where the case history is decided. |
|
CLP-01-002 |
MUST | A receiver MUST read a participant's ordinary activity in a case or proto-case flow as an assertion from the sender's role and the message's path alone; the protocol defines no separate "asserted mode" marker for it. The sender's role and the path of the message already show that a participant's activity is an assertion. A separate marker adds a field that every sender must set and every receiver must check, and a missing marker would then change the meaning of an ordinary message. |
|
CLP-01-004 |
MUST NOT | Participant replicas MUST NOT project shared case state directly from peer assertions A peer's activity is an assertion that the CASE_MANAGER has not yet admitted. A replica that applies it directly can hold state that the ledger never records, so it drifts from every other replica. Replicas stay equal only when each change comes from a ledger entry. |
|
CLP-02-006 |
MUST | CaseLedgerEntry MUST include a log_index field corresponding to SYNC-01-002.A replica uses the index to find its position in the ledger and to see a missing entry. Without an index on each entry, a replica cannot tell a gap from the end of the ledger. |
Uses definition from: SYNC-01-002 |
CLP-02-007 |
MAY | CaseLedgerEntry MAY include an optional term field reserved for Raft cluster use.In Raft, each entry carries the term of the leader that wrote it, and nodes compare terms to find entries from an old leader. A reserved field lets a cluster add that value without a change to the entry format that single-node deployments also read. |
|
CLP-02-008 |
MUST | The log_index field of a CaseLedgerEntry MUST be assigned by the CASE_MANAGER alone, when it commits the entry.Centralising log_index assignment in the single authoritative write path prevents gaps, duplicates, and out-of-order index values that would break hash-chain integrity. |
|
CLP-02-009 |
MUST NOT | The log_index field of a CaseLedgerEntry MUST NOT be assigned by external parties.Allowing external parties to set log_index would enable index spoofing, enabling forked or replayed ledger entries that corrupt the canonical append-only history. |
|
CLP-03-001 |
MUST | Only assertions that can be resolved to a specific case MUST be appended to the case audit ledger Every entry belongs to the hash chain of one case. An assertion that no case can claim has no chain to join, and an entry for it would break the rule that a ledger holds only the history of its own case. |
|
CLP-03-002 |
MUST | Malformed, unauthenticated, or otherwise unrouteable inbound messages that cannot be attached to a report or case MUST be handled outside the case audit ledger A message that the receiver cannot attach to a case tells the case nothing. It is a transport or sender problem, and the receiver's own log is the place to record it. If it went into a case ledger, any sender could add noise to a case it has no part in. |
|
CLP-04-002 |
MUST | Case-state reconstruction MUST use only the canonical case ledger; refused assertions are never committed to the ledger and therefore require no filter during reconstruction. A replica that rebuilds case state from any other source can get a different answer from every other replica. Because the ledger holds no refusals, a replay needs no filter, and so no filter rule can differ between implementations. |
|
CLP-04-004 |
MUST | CASE_MANAGER fan-out replication MUST deliver the canonical CaseLedgerEntry content, wrapped in an ActivityStreams transport envelope such as AnnounceA 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. |
|
CLP-04-005 |
SHOULD | When a participant includes log-position context with an assertion, it SHOULD use the last canonical hash or position the sender holds from the canonical case ledger A participant and the CASE_MANAGER compare positions to find a replica that lags. A position from any other source, such as the participant's own pending records, names a point that the canonical chain does not have. |
|
CLP-04-006 |
MUST | Implementations MUST derive case participant membership and case state only from the canonical recorded log, never from any other source. Membership and case state decide who receives case content and what each participant may do. If any other source could set them, two replicas at the same ledger position could disagree about who is in the case. |
|
CLP-05-003 |
MUST NOT | Implementations MUST NOT record local-only tracking markers or duplicate-detection markers as CaseLedgerEntry objects of any kind; such markers belong in ephemeral per-actor state, not in the canonical ledger.A duplicate marker or a local tracking marker is one actor's working state. If it is an entry, it replicates to every participant and becomes part of the hash chain. Then the chain depends on the timing of one actor's processing and not on the case history. |
|
CLP-06-001 |
SHOULD | Participant actors SHOULD maintain actor-local pending assertion state for recently emitted case-scoped assertions that are awaiting canonical CaseLedgerEntry confirmationA participant waits for its own assertion to come back as an entry. If it does not record that it is waiting, its behavior can send the same assertion again before the entry arrives. A short local record stops these duplicate sends. |
|
CLP-07-001 |
MUST | A CaseLedgerEntry committed to the canonical case ledger MUST correspond to exactly one CASE_MANAGER-accepted protocol-significant assertion. A state change the CASE_MANAGER itself writes is such an assertion, with the CASE_MANAGER as asserter. An example is the RM transitions it records for a leaving participant (CM-23-022).Each entry is one fact that every replica applies once. An entry that records no admitted assertion, or that records more than one, makes replicas apply something the CASE_MANAGER never decided, or lose part of what it decided. A change the CASE_MANAGER writes itself is also a fact, so it needs an entry like any other. |
See also: CM-23-022 — context for the reader |
CLP-07-004 |
MUST NOT | The canonical case ledger MUST NOT contain runtime diagnostics, demo checkpoints, synthetic verification markers, troubleshooting events, or any per-actor observability content; such content belongs in each actor's own logs. The ledger replicates to every participant and the hash chain covers it. Diagnostics and checkpoints depend on one actor's runtime. If they enter the ledger, replicas must filter them, and the chain changes when the timing of a run changes. An actor's own log can hold any detail with no effect on the protocol. |
|
CLP-08-003 |
MUST | The case-specific genesis hash MUST be stored on VulnerabilityCase as a required field computed at case creation time, so that receivers can verify that a ledger starts correctly for this caseA receiver checks the first entry of a ledger against the genesis hash. If the case does not carry the hash, each receiver must compute it again from fields it may not hold in the same form, and two receivers can get different values. A field set at creation gives every receiver the same value. |
|
CLP-08-006 |
MUST | The case URI used for origin-binding MUST contain a cryptographically random UUID component in its path segment to satisfy the non-spoofability guarantee of the per-case genesis hash (e.g., https://example.org/cases/<uuid>).A cryptographically random path segment makes the genesis hash unique and unguessable per case, so a ledger with all entries stripped is distinguishable from a legitimately new empty ledger. |
|
CLP-08-007 |
MUST NOT | Implementations MUST NOT use sequentially predictable or human-chosen path segments in the case URI when origin-binding integrity is required. Predictable or human-chosen path segments allow an attacker to pre-compute a valid genesis hash and construct a forged chain. See notes/case-ledger-authority.md for future improvement paths (secret nonce, CASE_MANAGER keypairs). |
|
PCR-01-001 |
MUST | Each Vultron Actor MUST maintain its local case replica as an internal concern — there is exactly one externally-addressable Actor identity per participant, regardless of how many cases that Actor is involved in. Other actors address an Actor, and decide whether to trust it, by its one id. A separate identity for each case would need its own discovery and its own trust anchor for every case, and a message sent to the Actor's main id would not reach the case. Keeping each replica inside the Actor gives every case the same inbox and the same identity. |
Derives from: CM-01-001 |
PCR-03-002 |
MUST NOT | The Case Owner actor MUST NOT write directly to its own local case copy. When the Case Owner is not the CASE_MANAGER, its copy of the case is a replica like every other, and it changes only after the CASE_MANAGER has checked the change and recorded it in the ledger. A direct write skips both steps, so the other replicas never learn of the change and the owner's copy then disagrees with the canonical case. |
Refines: PCR-03-005 |
PCR-03-003 |
MUST | A participant actor MUST authenticate Announce(VulnerabilityCase) activities before accepting them as authoritative updates to its local replica.The sender check of PCR-03-001 compares the activity's actor id, and a sender writes that id itself. Without authentication, any sender can write the CASE_MANAGER's id there and have its copy applied. Actor signatures are not yet available, so this rule applies to production only. |
|
PCR-04-002 |
MUST | All case-scoped protocol activities sent by the CASE_MANAGER to participants MUST carry context set to the case ID.A participant finds the replica an activity belongs to from its context (PCR-04-001). An activity from the CASE_MANAGER with no case context also skips the hold for unknown cases (PCR-06-002), so the participant can process it before it holds the case. |
|
PCR-04-003 |
MUST | A participant actor MUST be the only externally-addressable entity that receives case-scoped messages for the cases it takes part in. It has no separate per-case inbox. Other actors reach a participant at its one Actor identity (PCR-01-001). A separate inbox for each case would be a second address that senders must discover and trust for every case, and a message sent to the wrong address would not reach the replica. |
|
PCR-05-001 |
MUST | Each actor MUST keep, for each report it has submitted, a link from the report's id to the id of the case created for it. A reporter learns about the case for its report only from the activities it receives later. The link from the report to the case lets it find the case for the report it submitted, and it lets the reporter check that a case it receives is the case for that report (CBT-01-005). |
|
PCR-06-001 |
MUST NOT | When a participant actor receives an activity whose context field does not match any known local case replica, the actor MUST NOT silently discard the activity.Activities can arrive before the case they name, because the transport does not keep order (ADR-0161). The receiver has already taken delivery, so the sender has no reason to send the activity again, and a discarded activity is lost. Keeping it, or reporting the drop, keeps the participant from losing a case change without a record. |
|
PCR-06-003 |
MUST NOT | Activities with unknown case context MUST NOT update any local state until a valid case replica has been established. Until a replica exists, the participant has nothing to check an activity against: not the case, not its CASE_MANAGER, not its roster. A write made then could seed case state from an untrusted sender, which PCR-03-004 forbids for the case itself. |
|
PCR-08-002 |
MUST NOT | A participant actor MUST NOT assume that other participants will receive its case-scoped messages through any channel other than the CASE_MANAGER's Announce(CaseLedgerEntry) broadcast. Sending to the whole roster or any multi-recipient list that includes non-CASE_MANAGER actors is a violation of this rule.Only the CASE_MANAGER's Announce(CaseLedgerEntry) tells a participant what the case ledger holds. A participant that sends its message to other participants as well gives them a change that the CASE_MANAGER has not yet checked or recorded, and they may act on a change that the CASE_MANAGER later refuses. |
|
PCR-08-014 |
MUST NOT | The Case Owner MUST NOT author or emit any RM state-change activity on behalf of the invitee. RM state belongs to each participant, and it is the participant's own judgment (ADR-0121). Outside the bootstrap record of CBT-01-008, only that participant declares it. An RM change that the Case Owner emits for the invitee records a decision the invitee never made, and the case then shows the invitee engaged when it is not. |
Refines: PCR-08-010 |
SYNC-01-004 |
MUST | Canonical recorded log entries MUST be written only by the CASE_MANAGER. One writer gives one canonical order of entries. If two actors could write canonical entries, their ledgers could fork, and no rule could say which fork is the case history. |
|
SYNC-01-005 |
MUST | The hash-chain log entry format MUST be designed to be forward-compatible with a future Merkle Tree implementation A Merkle tree would let a peer prove that one entry is in the ledger without sending the whole chain. If the entry format blocks that change, a migration would have to rewrite every stored ledger, which an append-only ledger forbids. |
|
SYNC-06-001 |
SHOULD | Replication leadership SHOULD be treated as distinct from case ownership The Case Owner decides about the case, and the replication leader writes and sends the ledger. The Case Owner can hold the CASE_MANAGER role or give it to another actor, and a multi-node CASE_MANAGER can change its leader with no change of owner. If the two concepts are one, a change of either one forces a change of the other. |
|
SYNC-06-003 |
MUST | In a single-node deployment, the actor holding the CASE_MANAGER role MUST be treated as the permanent replication leader with exclusive write authority for its cases; no leader-election procedure is required. A single-node deployment is a degenerate Raft cluster of one: there is always a quorum (1/1) and no election can occur, so the CASE_MANAGER is permanently the leader without consensus overhead. This is the expected topology for the prototype phase. |
|
SYNC-08-001 |
MUST | Append-only integrity: a log entry MUST be immutable once committed. An entry that changes after commit no longer matches its hash, so every later entry in the chain breaks. A replica could also apply the changed entry and still pass the chain check. |
Refines: SYNC-00-005 — Restates the immutability of SYNC-00-005 as a system invariant |
SYNC-08-002 |
MUST | Deterministic projection: given an identical canonical recorded log prefix, all compliant implementations MUST derive identical state Each replica gets its case state from the ledger. The ledger keeps replicas in step only if the same entries always give the same state, on every implementation. Any other input, such as the local clock or the arrival order, would let two replicas with the same ledger disagree. |
|
SYNC-08-003 |
MUST NOT | Idempotent replay: reprocessing any canonical recorded log prefix (including duplicates) MUST NOT change the resulting state Replays, retries and restarts make an actor process some entries more than once. If a second pass changed the state, recovery itself would corrupt the case. |
|
SYNC-08-004 |
MUST NOT | Monotonic visibility: participants MUST NOT regress their acknowledged log position The CASE_MANAGER uses each peer's acknowledged position to decide what to send and when to replay. A position that moves back would make it send again entries the peer already holds, and could reset the replay cooldown. An acknowledged entry stays in the peer's append-only ledger, so a lower position is never true. |
|
SYNC-09-001 |
MUST | An implementation MUST treat a log entry as committed only once it is durably written to the authoritative log with its content hash recorded. A durable entry with its hash recorded survives a crash and can be checked on replay. An entry treated as committed before that could vanish while other actors already rely on it. |
|
SYNC-10-003 |
SHOULD | Catch-up freshness checks SHOULD use the actor's last acknowledged canonical hash and replay mechanisms so that action gating is based on canonical log position, not local wall-clock assumptions Clocks on different actors do not agree, and the time since the last message does not show whether an entry is missing. The hash of the last canonical entry is the same on every replica that holds the same prefix, so it is a reliable test of freshness. |
|
SYNC-14-004 |
MUST | Draining a held entry MUST apply the entry's domain effects before persisting it (SYNC-12-001). A drained entry becomes a stored entry like any other. The already-stored check relies on every stored entry having its effects applied, so the drain must keep the same order (SYNC-12-001). |
Refines: SYNC-12-001 — The drain MUST preserve the effects-before-persist invariant per applied entry |
SYNC-14-007 |
MUST NOT | The drain path MUST NOT re-apply effects for an entry already present in the local ledger (SYNC-12-003). Re-applying effects for a previously committed entry would cause duplicate state transitions and violate the idempotency guarantee established by SYNC-12-003. A replayed Announce reaches the same already-stored check as any delivery (SYNC-14-008), so an entry committed between its hold and its replay is skipped, not applied again. |
Refines: SYNC-12-003 |
SYNC-15-006 |
MUST NOT | A CaseLedgerEntry received when the per-case genesis hash is unavailable MUST NOT be treated as committed.Treating a pre-genesis entry as committed would populate the already-stored gate (SYNC-12-003) prematurely, causing effects to be skipped when the entry is later drained after the genesis is seeded. |
|
SYNC-15-007 |
MUST NOT | The domain effects of a CaseLedgerEntry received when the per-case genesis hash is unavailable MUST NOT be applied (SYNC-12-001).Applying effects before the genesis hash is known means the effects cannot be attributed to a verified chain position; if the genesis hash later reveals the entry is a fork, already-applied effects cannot be rolled back. |
See also: SYNC-12-001 — context for the reader |
Message Processing
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
EDF-03-004 |
MUST | The cascading consequence of a primary event MUST be fully determined by the handling actor's processing of that event, with no required intermediate local action, except at explicit external decision points (see EDF-04). A peer sees only what an actor emits. If an actor needs an extra local step before it completes the consequences of an event, its peers wait for something that the protocol does not show them. When the processing of the event alone determines its consequences, every implementation that receives the same event does the same work. The only exception is a point where the actor must wait for a decision (EDF-04). |
|
HP-00-001 |
MUST | A receiver MUST interpret received activities as assertions about the sender's state, not as commands to perform work Each actor owns its own state and decisions. If a receiver obeyed a message as a command, any sender could make it act. The receiver would also do the work again on each redelivery. When the receiver reads a message as an assertion, the message only updates what the receiver knows about the sender. The receiver keeps its own decisions. |
|
HP-00-002 |
MUST | A receiver MUST update its local RM/EM/CS state to reflect the state transition asserted by the received activity A receiver uses its view of the other parties to decide what to do next. For example, it checks whether an embargo is still active or whether a fix exists. The message is the only way that the receiver learns that the state of the sender changed. If the receiver did not record it, the receiver would act on a state that the sender has left. |
|
RF-03-002 |
SHOULD | Reject responses SHOULD include reason in content fieldA bare Reject tells the initiator that its proposal failed but not why, so it cannot correct the proposal or decide whether to escalate. A reason gives the participant something to act on; it is a SHOULD because a refusal can stand without one. |
|
RF-04-002 |
SHOULD | TentativeReject responses SHOULD include reason in content fieldA provisional refusal invites a revised proposal. Without a reason the initiator cannot tell what would make the proposal acceptable; it is a SHOULD because a refusal can stand without one. |
|
RF-05-001 |
SHOULD | Error responses SHOULD use ActivityStreams error extensions The protocol defines error messages whose recipients inquire about the error (VP-03-010, VP-03-011, VP-11-005). Expressed in the AS2 vocabulary, an error travels and is parsed through the same inbox pipeline as every other activity, with no second channel. |
|
RF-06-002 |
MUST | Response activities MUST be addressed to the INITIATING actor's inbox, not to the inbox that received the original activity Activities are state-change assertions; the initiator must receive the response to update their model of the case state |
|
RF-09-001 |
MUST | Response generation MUST be idempotent Delivery is at-least-once, so a receiver sees some activities more than once. If each copy produced a new response, the initiator would receive duplicate or conflicting answers and could apply the same state change twice. |
Transport and Security
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
ENC-02-001 |
MAY | Case participants MAY encrypt messages sent to the CASE_MANAGER using an encryption key the CASE_MANAGER publishes in its actor profile. Messages to the CASE_MANAGER can carry embargoed vul details that intermediaries must not read in transit. Encryption is optional because transport security can be enough for a deployment and no encryption scheme is yet standardized (ENC-02-002). |
Refines: VP-15-004 |
IE-11-002 |
MUST | The inbox endpoint MUST accept Activities whose addressing fields (to, cc, bto, bcc) are all absent or unresolvable (Liberal Accept). An address is unresolvable if it cannot be confirmed to refer to a specific individual actor — for example, a collection URI such as {case_id}/participants.Requiring explicit addressing would break flows where Activities are sent without formal addressing (e.g., internal relay, legacy senders). The narrowest thing that can be refused is provable exclusion; uncertainty defaults to acceptance. Fan-out deliveries using collection URIs (e.g. {case_id}/participants) cannot be resolved to individual actors at inbox processing time and must therefore be accepted. |
Inherited Requirements
Requirements
| ID | Priority | Requirement | Related |
|---|---|---|---|
MV-05-001 |
MUST | The system MUST validate that ID and reference fields contain valid URIs ActivityStreams 2.0 gives every id and every reference as an IRI, so a value that is not one is not a well-formed activity. Vultron inherits the rule. |
|
OID-01-002 |
MUST | IDs MUST be unique within the issuing actor's deployment; cross-deployment uniqueness is achieved by requiring full URI form (OID-01-001) with a deployment-controlled authority component. Restates ActivityPub's identifier rule: an object's URI has an authority belonging to the server that originated it, so that server keeps it unique and uniqueness across deployments follows from the full URI form. |
See also: OID-01-001 — context for the reader |
RF-06-001 |
MUST | Response activities MUST be delivered to the relevant actors' inboxes ActivityPub delivers every activity to the inboxes of its addressees; a response is no exception. Which actor a response goes to is Vultron's rule (RF-06-002). |