Skip to content
Reference

Considerations and References

This page is normative

This page is considered a core part of the Vultron Protocol. This is a normative section of the documentation.

The whole specification on one page

The specification is also published as a single page that holds every section and annex in order, for printing or for searching the whole text at once.

This page holds sections 15 to 17 of the Vultron Protocol Specification: the namespaces the protocol uses and what it asks of the Internet Assigned Numbers Authority (IANA), its security considerations, and the documents it cites. Several of its considerations concern the Hypertext Transfer Protocol (HTTP) transport.

15. IANA and Namespace Considerations [N/I]

Vultron vocabulary namespace. The Vultron ActivityStreams 2.0 (AS2) vocabulary namespace is https://certcc.github.io/Vultron/ns. This is the initial, provisional Uniform Resource Identifier (URI), hosted on GitHub Pages. A permanent URI registration (for example, via a w3id.org redirect) is planned for a future version of this specification. See ADR-0069.

JSON-LD context document. The normative JavaScript Object Notation for Linked Data (JSON-LD) context is identified by https://certcc.github.io/Vultron/ns/context.jsonld. Every outbound Vultron message lists this URI in its @context, after the AS2 namespace (§5.2 Serialization):

Requirements

ID Priority Requirement Related
VM-10-001 MUST Outbound Vultron wire messages MUST set the top-level @context to exactly the list ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld"], AS2 first, or, for a signed message (SIG-01-001), to exactly ["https://www.w3.org/ns/activitystreams", "https://certcc.github.io/Vultron/ns/context.jsonld", "https://w3id.org/security/data-integrity/v2"]: the data-integrity context is the third and final entry, and no other context is added.

Derived from ADR-0069 (docs/adr/0069-vultron-namespace-uri.md). AS2 Core §2.1 asks every producer to reference the ActivityStreams namespace in @context, and an AS2 receiver that does not process JSON-LD, as most ActivityPub software does not, recognizes a message by finding that exact string. The Vultron context declares the CVD-specific types (VulnerabilityCase, EmbargoEvent, etc.) that the ActivityStreams namespace does not. The Vultron context document also imports AS2, but a receiver need not dereference it (VM-10-003), so citing the Vultron URI alone hides the AS2 reference from a plain-JSON receiver.
Uses definition from: SIG-01-001

That URI does not currently dereference. The context document is withheld from publication until it is served at the wire-versioned path that ADR-0106 defines. At this version the namespace is therefore a stable identifier, not a retrievable document. A receiver processes a message without fetching it:

Requirements

ID Priority Requirement Related
VM-10-003 MUST NOT A receiver MUST NOT require dereferencing the Vultron JSON-LD context URI (VM-10-001) to process a message.

A receiver reads Vultron's compact JSON form and needs no JSON-LD expansion, so the context URI is an identifier, not an input. A fetch per message would also make processing depend on the network and on the host serving the context. Today the URI does not resolve at all: the context document is withheld until it is served at the wire-versioned path ADR-0106 defines, so a receiver that fetched it would fail on every sender's message.
Uses definition from: VM-10-001

AS2 extension type naming conventions. Vultron type names follow PascalCase without an as_ prefix in wire output (for example, "type": "VulnerabilityCase" rather than "type": "as:VulnerabilityCase"). The Vultron JSON-LD context declares all type names. A message still lists the AS2 namespace before the Vultron context URI in its @context, because a receiver need not fetch the Vultron context to learn that it imports AS2 (§5.2 Serialization).

IANA registration. No new IANA registrations are required by the current version of this specification. If the Vultron namespace moves to a standards-track document, an IANA media type registration for the Vultron JSON-LD profile may be appropriate at that time.


16. Security Considerations [N/I]

16.1 Trust Model

Actor identity. The protocol uses actor URIs as process identifiers. An actor URI is the identity anchor for all messages sent by that actor, and for the canonical case ledger if the actor holds the CASE_MANAGER role. Actor URI equality is identity equality:

Requirements

ID Priority Requirement Related
OID-01-010 MUST A receiver MUST treat two messages whose actor URIs are equal once a trailing slash is removed from each as coming from the same actor.

Actor ids are full URIs (OID-01-001), and two implementations that disagree on which messages share an actor disagree on who did what. The equality is the one a receiver normalises to (OID-01-006). This rule states identity, not trust: whether a message really comes from the actor it names is the signing work (ADR-0164). Revisit it when signing lands, in case identity should follow the signing key.
Uses definition from: OID-01-001

The rule states identity, not trust. Whether a message really comes from the actor that it names is the work of the signatures below.

Verification. An actor signs each activity that it sends with a proof inside the activity, in the FEP-8b32 eddsa-jcs-2022 form (SIG-01-001, SIG-01-002). A receiver refuses an activity whose proof is missing or does not verify (SIG-03-002). The receiver gets the key from the actor profile of the author, and from no other source (SIG-02-001).

The proof stays in the activity when the CASE_MANAGER relays it or records it in the case ledger. A replica can thus check who wrote each ledger entry that it applies (SIG-04-001, SIG-04-002). HTTP Message Signatures on each delivery are not required; a production deployment can add them to authenticate the server that delivers a request. The reference implementation signs each activity that it sends, and its inbox refuses an activity whose proof is missing or does not verify.

Case bootstrap as the trust establishment mechanism. The Create(VulnerabilityCase) message that the report receiver sends to the reporter as itself is the trust root for a case (§10.3 Case Bootstrap and the Trust Root). Late joiners receive a case snapshot and prior ledger entries from the CASE_MANAGER. A late joiner trusts the CASE_MANAGER's delivery because it trusts the invitation that named the CASE_MANAGER. This chain is the minimal trust model; cryptographic ledger integrity (hash-chaining) provides tamper detection.

See also

16.2 Embargo Integrity

Protocol adherence. An active embargo is an agreement, not a technical enforcement. The protocol provides the signaling infrastructure — Participant Embargo Consent (PEC) state tracks which participants have consented, §9.5 Embargo Traffic Reaches Non-Signatories ensures all participants receive meta-protocol messages — but it cannot prevent a participant from disclosing outside the protocol.

Defection. If a participant discloses publicly while an embargo is ACTIVE, the CP (public awareness) message will trigger the embargo teardown cascade (§11.3 Status Adoption: One Authorization Gate). The teardown is a state machine consequence, not a penalty mechanism. The protocol has no built-in penalty for defection; enforcement is an out-of-band organizational matter.

Confidentiality gate. Sensitive case content is gated on embargo consent (§9.7 Gating Full Case Delivery). While an embargo is in force, a participant that is not a signatory to it, because its consent row for that embargo is not AGREED, does not receive full case details. This is the primary technical lever the protocol provides against inadvertent over-disclosure to non-consenting parties.

16.3 Replay and Idempotency

Message deduplication. Each ActivityStreams Activity carries a unique id, so a receiver can recognize a message it has already processed. Duplicate delivery does not change state.

Ledger idempotency. The canonical case ledger is append-only and hash-chained. A re-delivered Add(CaseLedgerEntry) adds no second entry, and replaying entries a receiver already holds changes nothing. The ledger NAK path (Reject(CaseLedgerEntry)) and gap-fill replay provide recovery from missed entries. A participant's Read(<case>/ledger) position statement recovers a missed last entry, which no later entry exposes as a gap; the CASE_MANAGER answers it only from an active participant (SYNC-17-002). The one exception is the resend of the Invites a participant still on the roster owes an answer to: an Invite carries no withheld case content, so an inert participant is resent its Invites too (SYNC-20-001).

Requirements

ID Priority Requirement Related
ID-01-001 MUST All activities MUST have globally unique id field (URI)

ActivityPub requires every object, activities included, to carry a unique global identifier; ActivityStreams 2.0 alone leaves id optional. Duplicate detection (ID-02) relies on it.
SYNC-03-003 MUST NOT A receiver MUST NOT add a duplicate entry to its log when the same log entry is delivered again, so that replication is idempotent.

The outbox retries and replays send entries again, so a receiver often gets one entry more than once. A duplicate in the log would break the gapless index and the hash chain, and its effects would apply twice (ID-02-001).
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.

16.4 Confidentiality

In-transit protection. The protocol does not currently mandate a specific in-transit encryption mechanism. Transport Layer Security (TLS) is the expected transport protection for HTTP delivery. A future version of this specification is expected to require TLS.

Key management. Each actor generates its own unique asymmetric key pair when its identity is first provisioned. It publishes the public key in its actor profile and stores the private key securely. The key pair lasts for the lifetime of the actor identity: the actor reuses it after a process restart and does not generate a new one. A private key never appears in a log or an API response.

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-002 MUST Each actor MUST publish its public key in its actor profile as a Multikey listed under assertionMethod.

Peers need an actor's public key to verify the proofs it signs (SIG-02-001). assertionMethod is where an FEP-8b32 verifier looks for the key a proof's verificationMethod names, so no separate key-exchange channel is needed.
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
ENC-01-007 MUST NOT An implementation MUST NOT write a private key to a log or include one in an API response.

Logs and API responses are copied and retained widely, so a key that appears in them must be treated as disclosed. A prototype's seeded key makes no security claim, but code that leaks it would leak a production key the same way.
Extends: ENC-01-004

The rows on key generation, storage and persistence apply to a production deployment (ENC-01-001, ENC-01-004, ENC-01-005, ENC-01-006). The reference implementation is a prototype: it publishes each actor's key and keeps private keys out of logs and API responses (ENC-01-002, ENC-01-007). It does not yet generate, store or persist a key pair: it computes each actor's key pair from a seed tied to the actor id, which makes no security claim (#1184). Known Gaps lists the key management requirements that it does not yet meet.

Per-message encryption. A case participant can encrypt the messages it sends to the CASE_MANAGER. The CASE_MANAGER is expected to encrypt each message that it sends to a case participant individually. An encrypted message is encrypted to an encryption key that the recipient publishes in its actor profile. This version does not choose an encryption scheme, so until a scheme is standardized the choice is implementation-defined.

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
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

The reference implementation does not encrypt messages yet (#5388).

Confidentiality from the CASE_MANAGER. Content-level encryption that protects case details from the CASE_MANAGER itself, or that supports future multi-party computation, is not specified by this version. The CASE_MANAGER can read all case content that it receives, so that content is accessible to whoever operates the CASE_MANAGER.

Scope. This section covers the security requirements of the protocol as specified, including the key management and per-message encryption requirements above. Operational security practice beyond those requirements is out of scope. Examples are the means a deployment uses to protect stored keys, key backup and recovery, access control, and incident response for actor compromise.


17. References

17.1 Normative References

These documents are required to implement this specification.

Reference Title
RFC 2119 Key words for use in RFCs to Indicate Requirement Levels
RFC 8174 Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words
ActivityStreams 2.0 Core Activity Streams 2.0, World Wide Web Consortium (W3C) Recommendation
ActivityStreams 2.0 Vocabulary Activity Vocabulary, W3C Recommendation
JSON-LD 1.1 JSON-LD 1.1: A JSON-based Serialization for Linked Data, W3C Recommendation
RFC 8259 The JavaScript Object Notation (JSON) Data Interchange Format
FEP-8b32 Object Integrity Proofs, Fediverse Enhancement Proposal. The form of the proof an activity carries (§16.1 Trust Model)
Data Integrity EdDSA Cryptosuites Data Integrity EdDSA Cryptosuites v1.0, W3C Recommendation. Defines the eddsa-jcs-2022 cryptosuite
RFC 8785 JSON Canonicalization Scheme (JCS). The canonical form that eddsa-jcs-2022 signs, and that a case ledger entry hash covers (§5.2 Serialization)

17.2 Informative References

These documents provide context. They are not required to implement this specification.

Reference Title
ActivityPub ActivityPub, W3C Recommendation. The anticipated transport; not required by this version (§1.3 Relationship to Existing Standards)
ISO/IEC 29147:2018 Information technology — Security techniques — Vulnerability disclosure
ISO/IEC 30111:2019 Information technology — Security techniques — Vulnerability handling processes
CERT Guide to CVD The CERT Guide to Coordinated Vulnerability Disclosure. Source of this specification's definition of vulnerability (§2.1 Actors, Participants and Cases)
CVE Program Common Vulnerabilities and Exposures (CVE) Numbering Authority operational rules, referenced at §13.4.3 CVE ID Assignment
RFC 7033 WebFinger. The anticipated participant-discovery mechanism (§5.3 Transport)
RFC 9421 HTTP Message Signatures. Optional transport authentication for a production deployment, in addition to the proof in each activity (§16.1 Trust Model)