code wiki / _hdl_build / nx_sha256_longmsg_gate.nx
nx_sha256_longmsg_gate.nx source
↩ module page · 117 lines · 5996 B
1// nx_sha256_longmsg_gate.nx -- the MISSING KAT row, shipped as a ten-second organ
2// (Doctor+Builder, ENG-BROWSER visit 2026-06-11). WHY: the 2026-06-10 sha256 perf
3// rewrite (HASH-OPT, CAPREG377) was proven byte-identical by a golden diff roll over
4// inputs 0..256 BYTES -- but TLS transcript hashing feeds MULTI-KILOBYTE input through
5// the STREAMING path (init/update/final, arbitrary chunk seams). No gate covered
6// long inputs or streaming==one-shot equivalence. This organ closes that class:
7// K1 abc FIPS 180-2 vector, one-shot
8// K2 two-block-448 FIPS 180-2 vector (56 bytes, crosses one block seam), one-shot
9// K3 million-a FIPS 180-2 LONG vector (1,000,000 bytes), ONE-SHOT
10// K4 million-a-walk same vector via STREAMING updates with a mixed chunk walk
11// (1,63,64,65,255,256,257,1000,4096 cycling -- every buffer-seam
12// residue class) -- streaming must equal the published digest
13// K5 4k-equiv 4096-byte pattern: streaming(100-byte chunks) == one-shot
14// GREEN = the sha256 long/streaming class is exonerated forever (regression-gated);
15// RED = the defect is named mechanically, no human bisect.
16// Durable: SHALONG rows -> knowledge/status/sha256_longmsg.log. Exit 0 iff 5/5.
17// license_tier: ORIGINAL
18import "nx_syscalls.nx"
19import "nx_sha256.nx"
20func sl_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
21func sl_f(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
22func sl_n(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
23func sl_hex(out: *u8, dst: *u8) -> i64 {
24 let digits: *u8 = "0123456789abcdef" as *u8
25 var i: i64 = 0
26 while i < 32 {
27 let b: i64 = out[i] as i64
28 dst[i*2] = digits[(b >> 4) & 15]
29 dst[i*2+1] = digits[b & 15]
30 i = i + 1
31 }
32 dst[64] = 0 as u8
33 return 0
34}
35func sl_eq64(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while i < 64 { if a[i] != b[i] { return 0 } i = i + 1 } return 1 }
36func sl_row(lfd: i64, name: *u8, ok: i64, bad: *i64) -> i64 {
37 sl_f(lfd, "SHALONG row=" as *u8)
38 sl_f(lfd, name)
39 sl_p(" " as *u8); sl_p(name)
40 if ok == 1 { sl_f(lfd, " verdict=PASS\n" as *u8); sl_p(": PASS\n" as *u8) } else { sl_f(lfd, " verdict=FAIL\n" as *u8); sl_p(": FAIL\n" as *u8); bad[0] = bad[0] + 1 }
41 return 0
42}
43func main() -> i64 {
44 sl_p("=== SHA256 LONG-MSG GATE: the missing large-input + streaming-seam KAT row ===\n" as *u8)
45 let lfd: i64 = sys_openat_append("knowledge/status/sha256_longmsg.log" as *u8, 0x1a4)
46 if lfd < 0 { sl_p(" log open failed\n" as *u8); sys_exit(1); return 1 }
47 let bad: *i64 = sys_mmap(16) as *i64
48 bad[0] = 0
49 let out: *u8 = sys_mmap(64)
50 let hx: *u8 = sys_mmap(80)
51 let hx2: *u8 = sys_mmap(80)
52 // K1 abc
53 sha256_digest("abc" as *u8, 3, out)
54 sl_hex(out, hx)
55 sl_row(lfd, "abc" as *u8, sl_eq64(hx, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" as *u8), bad)
56 // K2 two-block 448-bit vector
57 sha256_digest("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" as *u8, 56, out)
58 sl_hex(out, hx)
59 sl_row(lfd, "two-block-448" as *u8, sl_eq64(hx, "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1" as *u8), bad)
60 // build the million-a buffer once
61 let mb: *u8 = sys_mmap(1000016)
62 var mi: i64 = 0
63 while mi < 1000000 { mb[mi] = 97 as u8; mi = mi + 1 }
64 // K3 million-a ONE-SHOT (the large-input row the rewrite never had)
65 sha256_digest(mb, 1000000, out)
66 sl_hex(out, hx)
67 sl_row(lfd, "million-a-oneshot" as *u8, sl_eq64(hx, "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" as *u8), bad)
68 // K4 million-a STREAMING with a mixed chunk walk over every seam residue class
69 let sz: *i64 = sys_mmap(80) as *i64
70 sz[0] = 1; sz[1] = 63; sz[2] = 64; sz[3] = 65; sz[4] = 255
71 sz[5] = 256; sz[6] = 257; sz[7] = 1000; sz[8] = 4096
72 let c: *Sha256 = sys_mmap(256) as *Sha256
73 sha256_init(c)
74 var off: i64 = 0
75 var si: i64 = 0
76 while off < 1000000 {
77 var take: i64 = sz[si % 9]
78 if off + take > 1000000 { take = 1000000 - off }
79 let base: i64 = mb as i64
80 sha256_update(c, (base + off) as *u8, take)
81 off = off + take
82 si = si + 1
83 }
84 sha256_final(c, out)
85 sl_hex(out, hx)
86 sl_row(lfd, "million-a-streamwalk" as *u8, sl_eq64(hx, "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0" as *u8), bad)
87 // K5 4KB pattern: streaming(100) == one-shot (self-equivalence on arbitrary data)
88 let pb: *u8 = sys_mmap(4112)
89 var pi: i64 = 0
90 while pi < 4096 { pb[pi] = ((pi * 31 + 7) % 256) as u8; pi = pi + 1 }
91 sha256_digest(pb, 4096, out)
92 sl_hex(out, hx)
93 let c2: *Sha256 = sys_mmap(256) as *Sha256
94 sha256_init(c2)
95 var o2: i64 = 0
96 while o2 < 4096 {
97 var t2: i64 = 100
98 if o2 + t2 > 4096 { t2 = 4096 - o2 }
99 let base2: i64 = pb as i64
100 sha256_update(c2, (base2 + o2) as *u8, t2)
101 o2 = o2 + t2
102 }
103 sha256_final(c2, out)
104 sl_hex(out, hx2)
105 sl_row(lfd, "4k-stream-eq-oneshot" as *u8, sl_eq64(hx, hx2), bad)
106 // durable verdict
107 sl_f(lfd, "SHALONG-GATE epoch=" as *u8)
108 sl_n(lfd, sys_now_realtime_sec())
109 sl_f(lfd, " rows=5 passed=" as *u8)
110 sl_n(lfd, 5 - bad[0])
111 if bad[0] == 0 { sl_f(lfd, " verdict=GREEN\n" as *u8) } else { sl_f(lfd, " verdict=RED\n" as *u8) }
112 sys_close(lfd)
113 if bad[0] == 0 { sl_p(" SHALONG-GATE: GREEN 5/5 (long+streaming sha256 class exonerated, regression-gated)\n" as *u8); sys_exit(0); return 0 }
114 sl_p(" SHALONG-GATE: RED (the defect is named mechanically -- fix sha256, re-run, never bisect by hand)\n" as *u8)
115 sys_exit(1)
116 return 1
117}