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

↩ module page · 287 lines · 13676 B
1// nx_hmacalt_extvec_gate.nx -- ADJUDICATES the hmac.nx FORK against RFC 4231 (all 7 HMAC-SHA-256 vectors).
2//
3// One import apart from nx_hmac_extvec_gate:
4//   nx_hmac_extvec_gate    -> nx_hmac.nx -> nx_sha256.nx   (7/7 GREEN)
5//   nx_hmacalt_extvec_gate ->    hmac.nx ->    sha256.nx   (9 live importers, NEVER GRADED)
6// Symbol parity verified: hmac.nx's functions all exist in nx_hmac.nx.
7// NOTE sha256.nx is a SHIM re-exporting nx_sha256.nx, so the CORE beneath this fork is already the
8// validated one -- what is under test here is the HMAC WRAPPER itself (key padding, ipad/opad, the
9// key-longer-than-block branch that RFC 4231 cases 6 and 7 exercise with a 131-byte key).
10// * TESTING A WRAPPER WHOSE CORE IS ALREADY EXONERATED IS STILL WORTH DOING -- HMAC's most commonly botched
11//   part is the key-shortening branch, which lives in the wrapper, not the hash.
12//// nx_hmacalt_extvec_gate.nx -- HMAC-SHA-256 vs RFC 4231, ALL SEVEN published test cases.
13//
14// SUPERSEDES the single-case version. Going from 1 vector to 7 matters because the cases are deliberately
15// chosen by the authority to hit DIFFERENT code paths, and the ones I was NOT running are the interesting
16// ones: case 3 uses a 50-byte repeated data block, cases 6 and 7 use a 131-BYTE KEY (longer than the 64-byte
17// SHA-256 block, so the key must be HASHED first), and case 5 publishes a TRUNCATED 128-bit MAC.
18// ★A gate that ran only case 1 would never touch the key-longer-than-block branch -- the single most
19// commonly botched part of HMAC. Running one vector from a seven-vector suite is not "validated against
20// RFC 4231"; it is validated against one line of it.
21//
22// ⚠VARIABLE-LENGTH FIELDS, HANDLED BY TERMINATOR NOT BY LENGTH. Key/Data lengths differ per case and their
23// annotations are inconsistent -- "(20 bytes)" for keys but ("Hi There") for data -- so a length cannot be
24// read uniformly. Instead the hex run is read until the first `(`, which terminates both forms.
25// ⚠THE MAC HAS NO `(` TERMINATOR and case 5's is TRUNCATED to 16 bytes, so it is read as hex pairs until a
26// pair is not both-hex, capped at 32. That correctly stops at the section heading that follows -- note
27// "4.3." begins with '4', a HEX DIGIT, and is only rejected because '.' is not: the PAIR rule saves this,
28// a single-nibble rule would have swallowed it.
29//
30// Construction unchanged: no expected value in this source, document pinned to a socket-time digest, every
31// key/data/MAC read from that pinned document, and a completeness check that refuses GREEN below 7.
32// license_tier: ORIGINAL  expect_exit: 0
33import "nx_syscalls.nx"
34import "nx_sha256_wasm.nx"
35import "hmac.nx"
36import "nx_gate_verdict.nx"
37
38func w(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
39func wb(b: *u8, n: i64) -> i64 { sys_write(1, b, n); return 0 }
40
41func 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
53}
54
55func hexnib(v: i64) -> i64 { if v < 10 { return 48 + v } return 87 + v }
56
57func 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
62}
63
64func 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
70}
71
72func 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
80}
81
82func 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
89}
90
91// Read hex PAIRS (whitespace between pairs is skipped) until a pair is not both-hex, or `(` is reached,
92// or cap is hit. Returns the byte count.
93func parserun(b: *u8, n: i64, from: i64, out: *u8, cap: i64) -> i64 {
  var p: i64 = from
  var got: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if got >= cap { done = 1 }
      else {
          // skip whitespace
          var d1: i64 = 0
          while d1 == 0 {
              if p >= n { d1 = 1 }
              else { if isws(b[p] as i64) == 1 { p = p + 1 } else { d1 = 1 } }
          }
          if p + 1 >= n { done = 1 }
          else {
              // `(` ends a LINE SEGMENT, not the value: RFC 4231 annotates EVERY wrapped line, e.g.
              //   Data = 7768...6e7420  ("what do ya want ")
              //          666f...693f    ("for nothing?")
              // Treating `(` as the value terminator stopped case 2 at 16 of its 28 bytes. On `(`, skip
              // to the next line and continue ONLY if it resumes with a hex pair; otherwise stop.
              if b[p] == (40 as u8) {
                  var dl: i64 = 0
                  while dl == 0 {
                      if p >= n { dl = 1 }
                      else { if b[p] == (10 as u8) { p = p + 1; dl = 1 } else { p = p + 1 } }
                  }
                  var dw: i64 = 0
                  while dw == 0 {
                      if p >= n { dw = 1 }
                      else { if isws(b[p] as i64) == 1 { p = p + 1 } else { dw = 1 } }
                  }
                  // ⚠"Da" IS VALID HEX. The next line may be `   Data =  7768...`, and testing only
                  // "do the first two chars parse as hex" accepted D,a and read the LABEL as byte 0xDA --
                  // adding one phantom byte to every key (case 1 read 21 of 20, case 2 read 5 of 4).
                  // Third form of the same hazard today: an ASCII gutter, then English prose, now a
                  // FIELD LABEL that happens to spell hex.
                  // STRUCTURAL DISCRIMINATOR: a continuation line has NO '='; every label line has one.
                  var eqfound: i64 = 0
                  var sc: i64 = p
                  var de: i64 = 0
                  while de == 0 {
                      if sc >= n { de = 1 }
                      else { if b[sc] == (10 as u8) { de = 1 }
                      else { if b[sc] == (61 as u8) { eqfound = 1; de = 1 } else { sc = sc + 1 } } }
                  }
                  if eqfound == 1 { done = 1 }
                  else {
                      if p + 1 >= n { done = 1 }
                      else {
                          if hexval(b[p] as i64) < 0 { done = 1 }
                          else { if hexval(b[p + 1] as i64) < 0 { done = 1 } }
                      }
                  }
              }
              else {
                  let h1: i64 = hexval(b[p] as i64)
                  let h2: i64 = hexval(b[p + 1] as i64)
                  if h1 < 0 { done = 1 }
                  else { if h2 < 0 { done = 1 }
                  else {
                      out[got] = ((h1 * 16) + h2) as u8
                      got = got + 1
                      p = p + 2
                  } }
              }
          }
      }
  }
  return got
162}
163
164// Find the next "Key" FIELD LABEL at line start. Verified against the raw bytes of RFC 4231:
165//   line 192 "   Key =          0b0b..."   <- cases 1,2,4,5,6,7
166//   line 251 "   Key            aaaa..."   <- CASE 3: no '=' at all
167//   line 177 "   Keys, data, and digests..." <- PROSE. "Key" is a PREFIX of "Keys".
168// Anchoring on "\n   Key" alone matched that prose line and drove the parse to ZERO cases. So the label is
169// accepted only when the character AFTER "Key" is a SPACE or '=' -- which "Keys" fails on 's'.
170// ★A prefix match is not a token match. Every anchor in this file is now checked against the byte AFTER it.
171func find_key_label(b: *u8, n: i64, from: i64) -> i64 {
  var p: i64 = from
  var done: i64 = 0
  while done == 0 {
      let h: i64 = findfrom(b, n, "\n   Key" as *u8, p)
      if h < 0 { return 0 - 1 }
      let c: i64 = b[h + 7] as i64
      if c == 32 { return h }
      if c == 61 { return h }
      p = h + 7
  }
  return 0 - 1
183}
184func main() -> i64 {
  w("nx_hmacalt_extvec_gate -- HMAC-SHA-256 vs RFC 4231, ALL 7 cases, READ FROM THE FETCHED DOCUMENT\n" as *u8)
186
  let lp: *i64 = sys_mmap(16) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file("knowledge/extvec/rfc4231.txt\x00" as *u8, lp)
  if lp[0] <= 0 { w("RED: fetched vector file absent -- run nx_vecfetch.\n" as *u8); return 1 }
191
  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 = "72178527ce93500e730bc8eb182b857e583096d652b64ece0879c52ba1df973b\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)
205
  let key: *u8 = sys_mmap(512)
  let data: *u8 = sys_mmap(512)
  let exp: *u8 = sys_mmap(64)
  let got: *u8 = sys_mmap(64)
210
  var pass: i64 = 0
  var fail: i64 = 0
  var seen: i64 = 0
  var cur: i64 = 0
  var done: i64 = 0
  while done == 0 {
      let lm: i64 = findfrom(b, lp[0], "HMAC-SHA-256 =" as *u8, cur)
      if lm < 0 { done = 1 }
      else {
          // the Key and Data for this case are the ones immediately BEFORE this MAC line
          // ⚠RFC 4231 CASE 3 WRITES `Key` WITH NO `=` -- every other case writes `Key =`. Anchoring on
          // "Key =" skipped case 3 entirely and matched CASE 4's key, which sits AFTER case 3's MAC.
          // The lk>lm guard below caught that and halted rather than pairing case 4's key with case 3's
          // MAC -- which would have produced a confident WRONG FAIL against a correct HMAC.
          // ★THE AUTHORITY'S OWN DOCUMENT IS INCONSISTENT, AND A READER MUST SURVIVE THAT WITHOUT
          // SILENTLY MIS-PAIRING. Anchor on "Key" and skip an OPTIONAL "=".
          let lk: i64 = find_key_label(b, lp[0], cur)
          let ld: i64 = findfrom(b, lp[0], "Data =" as *u8, cur)
          if lk < 0 { done = 1 }
          else { if ld < 0 { done = 1 }
          else { if lk > lm { done = 1 }
          else {
              var ks: i64 = lk + 7
              var dks: i64 = 0
              while dks == 0 {
                  if ks >= lp[0] { dks = 1 }
                  else { if b[ks] == (32 as u8) { ks = ks + 1 }
                  else { if b[ks] == (61 as u8) { ks = ks + 1 } else { dks = 1 } } }
              }
              let klen: i64 = parserun(b, lp[0], ks, key, 400)
              let dlen: i64 = parserun(b, lp[0], ld + 6, data, 400)
              let elen: i64 = parserun(b, lp[0], lm + 14, exp, 32)
              if klen <= 0 { done = 1 }
              else { if elen <= 0 { done = 1 }
              else {
                  hmac_sha256(key, klen, data, dlen, got)
                  var same: i64 = 1
                  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 case " as *u8); nn(seen)
                      w(": keylen=" as *u8); nn(klen); w(" datalen=" as *u8); nn(dlen)
                      w(" maclen=" as *u8); nn(elen); w("\n" as *u8)
                  } else {
                      fail = fail + 1
                      w("  FAIL case " as *u8); nn(seen); w(": keylen=" as *u8); nn(klen)
                      w(" datalen=" as *u8); nn(dlen); w(" maclen=" as *u8); nn(elen); w("\n" as *u8)
                  }
                  cur = lm + 14
              } }
          } } }
      }
  }
266
  // RFC 4231 publishes SEVEN cases. Grading fewer while printing GREEN is coverage-gaming -- this exact
  // check is what exposed a swallowed vector in the MD5 gate earlier today.
  if seen != 7 {
      w("  RED: parsed " as *u8); nn(seen); w(" of 7 published cases -- refusing GREEN on a partial read.\n" as *u8)
      fail = fail + 1
  }
273
  w("\n  refsrc=https://www.rfc-editor.org/rfc/rfc4231.txt\n" as *u8)
  w("  refsrcdig=" as *u8); wb(hx, 64); w("\n" as *u8)
  w("  ref=RFC4231-all-cases   gate=nx_hmacalt_extvec_gate\n" as *u8)
  w("nx_hmacalt_extvec_gate: cases=" 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("HMAC-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
287}
nx_hmacalt_extvec_gate.nx source

`nx_hmacalt_extvec_gate.nx` source
