Skip to main content

qualia_core_db/net/qdnf/harness/
review_packet.rs

1//! E21.3 — independent-review PACKET. Prepared in-tree; review is not executed.
2
3/// Independent cryptographic composition / hostile-environment review has not
4/// been commissioned or signed.
5pub fn independent_review_executed() -> bool {
6    false
7}
8
9/// The checklist packet exists and is filled with unsigned prepared items.
10pub fn review_packet_prepared() -> bool {
11    true
12}
13
14/// An item is ready for a human reviewer. It is never a signed attestation.
15#[repr(u8)]
16#[derive(Clone, Copy, Debug, PartialEq, Eq)]
17pub enum ReviewStatus {
18    PreparedAwaitingReviewer = 1,
19}
20
21/// One composition / hostile-environment checklist row.
22#[derive(Clone, Copy, Debug, PartialEq, Eq)]
23pub struct ReviewItem {
24    pub id: &'static str,
25    pub topic: &'static str,
26    pub status: ReviewStatus,
27    /// Always false: this packet does not claim a reviewer signature.
28    pub signed_by_reviewer: bool,
29}
30
31impl ReviewItem {
32    const fn prepared(id: &'static str, topic: &'static str) -> Self {
33        Self {
34            id,
35            topic,
36            status: ReviewStatus::PreparedAwaitingReviewer,
37            signed_by_reviewer: false,
38        }
39    }
40}
41
42/// Composition review packet. Not a completed independent review.
43#[derive(Clone, Copy, Debug, PartialEq, Eq)]
44pub struct IndependentReviewPacket {
45    pub handshake_transcript: ReviewItem,
46    pub ml_dsa_identity: ReviewItem,
47    pub protection_labels: ReviewItem,
48    pub session_key_confirmation: ReviewItem,
49    pub hostile_environment: ReviewItem,
50}
51
52impl IndependentReviewPacket {
53    /// `IndependentReviewPacket::prepared`.
54    pub const fn prepared() -> Self {
55        Self {
56            handshake_transcript: ReviewItem::prepared(
57                "e21.3/handshake",
58                "QPR handshake transcript binding and identity mix",
59            ),
60            ml_dsa_identity: ReviewItem::prepared(
61                "e21.3/ml-dsa",
62                "ML-DSA-65 identity signatures; no length-inferred algorithm",
63            ),
64            protection_labels: ReviewItem::prepared(
65                "e21.3/labels",
66                "Protection labels, join, declassify, and egress markings",
67            ),
68            session_key_confirmation: ReviewItem::prepared(
69                "e21.3/session-keys",
70                "Installed session keys and confirmation; no unkeyed finished",
71            ),
72            hostile_environment: ReviewItem::prepared(
73                "e21.3/hostile-env",
74                "Hostile-environment composition (partition, replay, downgrade)",
75            ),
76        }
77    }
78
79    /// `IndependentReviewPacket::items`.
80    pub const fn items(self) -> [ReviewItem; 5] {
81        [
82            self.handshake_transcript,
83            self.ml_dsa_identity,
84            self.protection_labels,
85            self.session_key_confirmation,
86            self.hostile_environment,
87        ]
88    }
89
90    /// No item is a signed review finding.
91    pub fn any_signed(self) -> bool {
92        let items = self.items();
93        let mut i = 0usize;
94        while i < items.len() {
95            if items[i].signed_by_reviewer {
96                return true;
97            }
98            i += 1;
99        }
100        false
101    }
102}
103
104/// Construct the prepared packet. Does not execute or attest a review.
105pub fn prepared_review_packet() -> IndependentReviewPacket {
106    IndependentReviewPacket::prepared()
107}
108
109#[cfg(test)]
110mod tests {
111    use super::*;
112    use crate::net::qdnf::harness::claims::independent_review_commissioned;
113    use crate::net::qdnf::harness::limitations::INDEPENDENT_CRYPTO_REVIEW;
114
115    #[test]
116    fn review_packet_is_prepared_and_unsigned() {
117        assert!(review_packet_prepared());
118        assert!(!independent_review_executed());
119        assert!(!independent_review_commissioned());
120        let packet = prepared_review_packet();
121        assert!(!packet.any_signed());
122        let items = packet.items();
123        assert_eq!(items.len(), 5);
124        let mut i = 0usize;
125        while i < items.len() {
126            assert!(!items[i].signed_by_reviewer);
127            assert_eq!(items[i].status, ReviewStatus::PreparedAwaitingReviewer);
128            assert!(!items[i].id.is_empty());
129            i += 1;
130        }
131        assert!(INDEPENDENT_CRYPTO_REVIEW.contains("not executed"));
132        assert!(packet.handshake_transcript.topic.contains("handshake"));
133        assert!(packet.ml_dsa_identity.topic.contains("ML-DSA"));
134        assert!(packet.protection_labels.topic.contains("label"));
135        assert!(packet.session_key_confirmation.topic.contains("session"));
136    }
137}