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

↩ module page · 179 lines · 7778 B
1// nx_base32_extvec_gate.nx -- TWELFTH provably third-party-validated claim, from the same pinned document as the eighth. Base32 is a DIFFERENT alphabet and a DIFFERENT pad arithmetic than Base64 -- sharing a source does not make it the same claim. First OUTSIDE
2// cryptography: Base64 vs RFC 4648 section 10.
3//
4// ★A FIFTH VECTOR DIALECT. The previous seven gates read hex in four different layouts; RFC 4648 states
5// its vectors as QUOTED ASCII:
6//     BASE32("") = ""
7//     BASE32("f") = "Zg=="
8//     BASE32("foobar") = "Zm9vYmFy"
9// No hex reader touches this. ★The recurring lesson of this session, once more: there is no general
10// parser, only one proven against the section in front of you.
11//
12// Construction unchanged from the other seven: nothing expected appears in this source, the document is
13// pinned to a digest nx_vecfetch computed IN-PROCESS AT THE SOCKET, and every input AND output below is
14// read out of that pinned document at run time.
15// ★THE EMPTY-STRING VECTOR IS KEPT DELIBERATELY. BASE32("") = "" is the case an encoder is most likely to
16// get wrong (a stray pad, a spurious byte) and the one a hand-written test is most likely to omit. The
17// authority published it; we do not get to skip it.
18// license_tier: ORIGINAL  expect_exit: 0
19import "nx_syscalls.nx"
20import "nx_sha256_wasm.nx"
21import "nx_base32.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 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
51}
52
53func 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
60}
61
62// Copy the run of bytes from `from` up to (not including) the next double-quote. Returns the length, or -1
63// if no closing quote appears. Empty is a VALID result -- BASE32("") = "" is a real published vector, so a
64// zero length must never be treated as a parse failure.
65func 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 k >= cap { return 0 - 1 }
      out[k] = b[p]
      k = k + 1
      p = p + 1
  }
  return 0 - 1
76}
77
78func main() -> i64 {
  w("nx_base32_extvec_gate -- Base32 vs RFC 4648 section 10, READ FROM THE FETCHED DOCUMENT\n" as *u8)
80
  let lp: *i64 = sys_mmap(16) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file("knowledge/extvec/rfc4648.txt\x00" as *u8, lp)
  if lp[0] <= 0 { w("RED: fetched vector file absent -- run nx_vecfetch.\n" as *u8); return 1 }
85
  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 = "84e14418f795d503be5f34bf23ce4ebaa119e9ec7c9f667d8caeb111385b178f\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)
99
  // Anchor on the SECTION BODY, not the contents line: "10.  Test Vectors" (two spaces) appears in the
  // body; the TOC line reads "10. Test Vectors ....". Take the last occurrence to be safe.
  var at: i64 = 0
  var scan: i64 = 0
  var dsec: i64 = 0
  while dsec == 0 {
      let h: i64 = findfrom(b, lp[0], "BASE32(\"" as *u8, scan)
      if h < 0 { dsec = 1 } else { if at == 0 { at = h } scan = h + 8 }
  }
  if at == 0 { w("RED: no BASE32(\") vectors found\n" as *u8); return 1 }
110
  let inb: *u8 = sys_mmap(64)
  let exp: *u8 = sys_mmap(64)
  let got: *u8 = sys_mmap(128)
  let ep: *i64 = sys_mmap(16) as *i64
115
  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], "BASE32(\"" as *u8, cur)
      if h < 0 { done = 1 }
      else {
          ep[0] = 0
          let inlen: i64 = parseq(b, lp[0], h + 8, inb, 60, ep)
          if inlen < 0 { done = 1 }
          else {
              let q: i64 = findfrom(b, lp[0], "= \"" as *u8, ep[0])
              if q < 0 { done = 1 }
              else {
                  ep[0] = 0
                  let elen: i64 = parseq(b, lp[0], q + 3, exp, 60, ep)
                  if elen < 0 { done = 1 }
                  else {
                      let glen: i64 = base32_encode(inb, inlen, got)
                      var same: i64 = 1
                      if glen != elen { same = 0 }
                      else { i = 0; while i < elen { if got[i] != exp[i] { same = 0 } i = i + 1 } }
                      seen = seen + 1
                      if same == 1 {
                          pass = pass + 1
                          w("  PASS BASE32(\"" as *u8); wb(inb, inlen); w("\") == \"" as *u8); wb(exp, elen); w("\"\n" as *u8)
                      } else {
                          fail = fail + 1
                          w("  FAIL BASE32(\"" as *u8); wb(inb, inlen); w("\") expected \"" as *u8); wb(exp, elen)
                          w("\" got \"" as *u8); wb(got, glen); w("\"\n" as *u8)
                      }
                      cur = ep[0]
                  }
              }
          }
      }
  }
155
  // The authority publishes SEVEN Base64 vectors in section 10 (empty through "foobar"). Finding fewer
  // means the reader lost some -- and a gate that silently grades 3 of 7 while printing GREEN is exactly
  // the coverage-gaming this workstream exists to stop.
  if seen < 7 {
      w("  RED: only " as *u8); nn(seen); w(" vectors parsed; RFC 4648 section 10 publishes 7.\n" as *u8)
      w("       Refusing to report GREEN on a partial read of the authority.\n" as *u8)
      fail = fail + 1
  }
164
  w("\n  refsrc=https://www.rfc-editor.org/rfc/rfc4648.txt\n" as *u8)
  w("  refsrcdig=" as *u8); wb(hx, 64); w("\n" as *u8)
  w("  ref=RFC4648-10-base32   gate=nx_base32_extvec_gate\n" as *u8)
  w("nx_base32_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("BASE32-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
179}
nx_base32_extvec_gate.nx source

`nx_base32_extvec_gate.nx` source
