code wiki / _hdl_build / nx_md5_extvec_gate.nx
`nx_md5_extvec_gate.nx` source

↩ module page · 207 lines · 8726 B
1// nx_md5_extvec_gate.nx -- TENTH provably third-party-validated claim: MD5 vs the RFC 1321 test suite.
2//
3// ⚠TWO OF THE SEVEN VECTORS WRAP ACROSS LINES, AND ONE OF THEM WRAPS *INSIDE THE QUOTED INPUT*:
4//     MD5 ("123456789012345678901234567890123456789012345678901234567890123456
5//     78901234567890") = 57edf4a22be3c955ac49da2e2107b67a
6// A naive "copy bytes until the closing quote" reader would put a newline INTO the message, hash the wrong
7// bytes, and report a broken MD5. So this reader SKIPS \n and \r while copying a quoted value.
8// ★THAT IS AN ASSUMPTION ABOUT THIS SECTION, AND IT IS STATED RATHER THAN HIDDEN: the RFC 1321 test inputs
9// are printable ASCII containing no literal newline, so dropping newlines restores exactly the intended
10// message. It would be WRONG for any document whose test inputs legitimately contain newlines -- do not
11// lift this reader to such a source without re-proving it.
12// ★Sixth vector dialect of the session. The lesson has not changed once: there is no general parser, only
13// one proven against the section in front of you.
14//
15// Construction identical to the other nine: no expected value in this source, document pinned to a digest
16// nx_vecfetch computed IN-PROCESS AT THE SOCKET, inputs AND digests read from that pinned document, and a
17// completeness check so a partial read cannot print GREEN.
18// license_tier: ORIGINAL  expect_exit: 0
19import "nx_syscalls.nx"
20import "nx_sha256_wasm.nx"
21import "nx_md5_canonical.nx"
22import "nx_gate_verdict.nx"
23
24func w(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
25func wb(b: *u8, n: i64) -> i64 { sys_write(1, b, n); return 0 }
26
27func nn(v: i64) -> i64 {
  var m: i64 = v
  if m < 0 { w("-" as *u8); m = 0 - m }
  let t: *u8 = sys_mmap(32)
  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 }
  let b: *u8 = sys_mmap(32)
  var j: i64 = 0
  while j < k { b[j] = t[k - 1 - j]; j = j + 1 }
  sys_write(1, b, k)
  return 0
39}
40
41func hexnib(v: i64) -> i64 { if v < 10 { return 48 + v } return 87 + v }
42
43func hexval(c: i64) -> i64 {
  if c >= 48 { if c <= 57 { return c - 48 } }
  if c >= 97 { if c <= 102 { return c - 87 } }
  if c >= 65 { if c <= 70 { return c - 55 } }
  return 0 - 1
48}
49
50func isws(c: i64) -> i64 {
  if c == 32 { return 1 }
  if c == 10 { return 1 }
  if c == 13 { return 1 }
  if c == 9 { return 1 }
  return 0
56}
57
58func starts(b: *u8, n: i64, at: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) {
      if at + i >= n { return 0 }
      if b[at + i] != s[i] { return 0 }
      i = i + 1
  }
  return 1
66}
67
68func findfrom(b: *u8, n: i64, s: *u8, from: i64) -> i64 {
  var p: i64 = from
  while p < n {
      if starts(b, n, p, s) == 1 { return p }
      p = p + 1
  }
  return 0 - 1
75}
76
77// Copy a quoted value, DROPPING the document's line wraps (\n, \r). Empty is valid: MD5 ("") is vector 1.
78func parseq(b: *u8, n: i64, from: i64, out: *u8, cap: i64, endout: *i64) -> i64 {
  var p: i64 = from
  var k: i64 = 0
  while p < n {
      if b[p] == (34 as u8) { endout[0] = p; return k }
      if b[p] == (10 as u8) { p = p + 1 }
      else { if b[p] == (13 as u8) { p = p + 1 }
      else {
          if k >= cap { return 0 - 1 }
          out[k] = b[p]
          k = k + 1
          p = p + 1
      } }
  }
  return 0 - 1
93}
94
95// Read `want` bytes of hex; whitespace continues the run (the digest may sit on the following line).
96func parsehex(b: *u8, n: i64, from: i64, out: *u8, want: i64, endout: *i64) -> i64 {
  var p: i64 = from
  var got: i64 = 0
  while p < n {
      if got >= want { endout[0] = p; return got }
      let c: i64 = b[p] as i64
      if isws(c) == 1 { p = p + 1 }
      else {
          let h1: i64 = hexval(c)
          if h1 < 0 { return 0 - 1 }
          if p + 1 >= n { return 0 - 1 }
          let h2: i64 = hexval(b[p + 1] as i64)
          if h2 < 0 { return 0 - 1 }
          out[got] = ((h1 * 16) + h2) as u8
          got = got + 1
          p = p + 2
      }
  }
  if got >= want { endout[0] = p; return got }
  return 0 - 1
116}
117
118func main() -> i64 {
  w("nx_md5_extvec_gate -- MD5 vs the RFC 1321 test suite, READ FROM THE FETCHED DOCUMENT\n" as *u8)
120
  let lp: *i64 = sys_mmap(16) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file("knowledge/extvec/rfc1321.txt\x00" as *u8, lp)
  if lp[0] <= 0 { w("RED: fetched vector file absent -- run nx_vecfetch.\n" as *u8); return 1 }
125
  let ctx: *u8 = sys_mmap(1024)
  let dg: *u8 = sys_mmap(64)
  nx_sha256_one_shot(b, lp[0], ctx, dg)
  let hx: *u8 = sys_mmap(80)
  var i: i64 = 0
  while i < 32 { hx[i*2] = hexnib(((dg[i] as i64)/16)&15) as u8; hx[i*2+1] = hexnib((dg[i] as i64)&15) as u8; i = i + 1 }
  let wnt: *u8 = "284a79d148400d9cd2a423211d1103b5cef0fb9256a4cbe6d7ebe5197c3149dd\x00" as *u8
  var pin: i64 = 1
  i = 0
  while i < 64 { if hx[i] != wnt[i] { pin = 0 } i = i + 1 }
  w("  acquisition digest: " as *u8); wb(hx, 64); w("\n" as *u8)
  if pin == 0 { w("RED: PIN FAILED -- not the file nx_vecfetch acquired.\n" as *u8); return 1 }
  w("  PIN OK -- bytes match the digest computed in-process at the socket\n" as *u8)
139
  let at: i64 = findfrom(b, lp[0], "MD5 test suite:" as *u8, 0)
  if at < 0 { w("RED: no 'MD5 test suite:' block\n" as *u8); return 1 }
142
  let inb: *u8 = sys_mmap(256)
  let exp: *u8 = sys_mmap(64)
  let got: *u8 = sys_mmap(64)
  let ep: *i64 = sys_mmap(16) as *i64
147
  var pass: i64 = 0
  var fail: i64 = 0
  var seen: i64 = 0
  var cur: i64 = at
  var done: i64 = 0
  while done == 0 {
      let h: i64 = findfrom(b, lp[0], "MD5 (\"" as *u8, cur)
      if h < 0 { done = 1 }
      else {
          ep[0] = 0
          let inlen: i64 = parseq(b, lp[0], h + 6, inb, 250, ep)
          if inlen < 0 { done = 1 }
          else {
              // The separator is "=" ALONE, not "= ". Vector 6 prints ") =" then a NEWLINE before its
              // digest, so matching "= " skipped it, ran on, and stole VECTOR 7's digest -- corrupting
              // one vector and consuming another. One wrong separator, two symptoms.
              // The completeness check (7 published) is what surfaced the swallowed vector; without it
              // this gate would have reported 6 parsed / 5 passed and looked merely "mostly fine".
              let q: i64 = findfrom(b, lp[0], "=" as *u8, ep[0])
              if q < 0 { done = 1 }
              else {
                  ep[0] = 0
                  if parsehex(b, lp[0], q + 1, exp, 16, ep) < 0 { done = 1 }
                  else {
                      md5(inb, inlen, got)
                      var same: i64 = 1
                      i = 0
                      while i < 16 { if got[i] != exp[i] { same = 0 } i = i + 1 }
                      seen = seen + 1
                      if same == 1 { pass = pass + 1; w("  PASS MD5 len=" as *u8); nn(inlen); w("\n" as *u8) }
                      else { fail = fail + 1; w("  FAIL MD5 len=" as *u8); nn(inlen); w(" digest mismatch\n" as *u8) }
                      cur = ep[0]
                  }
              }
          }
      }
  }
185
  // RFC 1321 publishes SEVEN vectors. Grading fewer while printing GREEN is coverage-gaming.
  if seen < 7 {
      w("  RED: only " as *u8); nn(seen); w(" of 7 published vectors parsed -- refusing GREEN on a partial read.\n" as *u8)
      fail = fail + 1
  }
191
  w("\n  refsrc=https://www.rfc-editor.org/rfc/rfc1321.txt\n" as *u8)
  w("  refsrcdig=" as *u8); wb(hx, 64); w("\n" as *u8)
  w("  ref=RFC1321-test-suite   gate=nx_md5_extvec_gate\n" as *u8)
  w("  NOTE: MD5 is cryptographically BROKEN for collision resistance. This gate proves CONFORMANCE to\n" as *u8)
  w("        the published digest values only -- it is not an endorsement of MD5 for any security use.\n" as *u8)
  w("nx_md5_extvec_gate: vectors=" as *u8); nn(seen); w(" pass=" as *u8); nn(pass); w(" fail=" as *u8); nn(fail)
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = pass
  ctr__dry[1] = pass + fail
  let rc__dry: i64 = gv_verdict("MD5-EXTVEC-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
207}
nx_md5_extvec_gate.nx source

`nx_md5_extvec_gate.nx` source
