Skip to main content

qualia_core_db/net/qdnf/harness/
claims.rs

1//! E21.5 honesty claims. Test counts are not certification.
2//!
3//! A bounded in-process header-byte loop exists in this module. That is not
4//! libFuzzer, not a model checker, and not the E21.2 fuzz suite.
5
6use crate::net::qdnf::errors::QdnfError;
7use crate::net::qdnf::frame::{decode_frame, BASE_HEADER_LEN};
8use crate::net::qdnf::harness::oracle::independent_decode_header;
9
10/// Passing unit tests do not certify a deployment.
11pub fn test_count_is_certification() -> bool {
12    false
13}
14
15/// Independent cryptographic / hostile-environment review is not commissioned.
16pub fn independent_review_commissioned() -> bool {
17    false
18}
19
20/// E21.2 libFuzzer / model-check suite has not been executed.
21pub fn fuzz_suite_executed() -> bool {
22    false
23}
24
25/// Bounded in-process header codec loop (not libFuzzer).
26pub const IN_PROCESS_HEADER_FUZZ_TRIALS: usize = 320;
27
28/// True when the in-process header loop is part of this crate's tests.
29pub fn in_process_header_codec_fuzz_executed() -> bool {
30    true
31}
32
33fn base_header() -> [u8; BASE_HEADER_LEN] {
34    let mut src = [0u8; BASE_HEADER_LEN];
35    src[0] = b'Q';
36    src[1] = b'D';
37    src[2] = b'N';
38    src[3] = b'F';
39    src[4] = 1;
40    src[5] = 2;
41    src[8] = 0;
42    src[9] = 80;
43    src[12] = 0;
44    src[13] = 1;
45    src
46}
47
48fn mix(mut x: u64) -> u64 {
49    x ^= x.wrapping_shl(13);
50    x ^= x.wrapping_shr(7);
51    x ^= x.wrapping_shl(17);
52    x
53}
54
55/// Deterministic in-process mutations over an 80-byte QFrame header.
56///
57/// Each trial calls the production decoder and the independent oracle.
58/// Outcomes are [`QdnfError`] codes or a decoded header. No payload is echoed.
59pub fn in_process_header_codec_fuzz() -> Result<usize, QdnfError> {
60    let mut trials = 0usize;
61    let mut seed = 0xA5A5_C3C3_u64;
62    let mut i = 0usize;
63    while i < IN_PROCESS_HEADER_FUZZ_TRIALS {
64        let mut src = base_header();
65        seed = mix(seed.wrapping_add(i as u64));
66        let idx = (seed as usize) % BASE_HEADER_LEN;
67        src[idx] = (seed >> 8) as u8;
68        seed = mix(seed);
69        let idx2 = (seed as usize) % BASE_HEADER_LEN;
70        src[idx2] = src[idx2].wrapping_add((i as u8).wrapping_mul(17));
71        let _ = decode_frame(&src);
72        let _ = independent_decode_header(&src);
73        trials = trials.saturating_add(1);
74        i = i.saturating_add(1);
75    }
76    if trials != IN_PROCESS_HEADER_FUZZ_TRIALS {
77        return Err(QdnfError::Range);
78    }
79    Ok(trials)
80}
81
82#[cfg(test)]
83mod tests {
84    use super::*;
85    use crate::net::qdnf::harness::scenarios::{qualified_count, ScenarioId};
86
87    #[test]
88    fn honesty_flags_are_negative() {
89        assert!(!test_count_is_certification());
90        assert!(!independent_review_commissioned());
91        assert!(!fuzz_suite_executed());
92        assert_eq!(qualified_count(), 0);
93        assert_eq!(ScenarioId::COUNT, 40);
94    }
95
96    #[test]
97    fn in_process_header_fuzz_is_bounded_and_does_not_echo() {
98        assert!(in_process_header_codec_fuzz_executed());
99        let n = in_process_header_codec_fuzz().unwrap();
100        assert_eq!(n, IN_PROCESS_HEADER_FUZZ_TRIALS);
101        let mut bad = base_header();
102        bad[0] = b'X';
103        let err = decode_frame(&bad).unwrap_err();
104        assert_eq!(err, QdnfError::Malformed);
105        assert_eq!(err.to_string(), "malformed");
106        assert_eq!(independent_decode_header(&bad), Err(QdnfError::Malformed));
107    }
108}