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

↩ module page · 234 lines · 9998 B
1// nx_hotp_extvec_gate.nx -- HOTP vs RFC 4226 Appendix D, all TEN published values.
2//
3// ★WHY THIS GATE EXISTS: I claimed all session that HOTP/TOTP two-factor codes were BROKEN (they rode the
4// defective sha1.nx core) and that repointing hmac_sha1.nx REPAIRED them. The first half was proven; the
5// second half was INFERRED. I had shown HMAC-SHA-1 now matches RFC 2202 -- I had never once computed an
6// actual HOTP code and compared it to a published one.
7// ★★★★★"THE PRIMITIVE UNDERNEATH IT IS NOW CORRECT" IS NOT THE SAME CLAIM AS "THIS PRODUCES CORRECT
8//  OUTPUT." HOTP adds dynamic truncation and modular reduction ON TOP of HMAC; a correct HMAC does not
9//  prove a correct truncation, and the truncation is where HOTP implementations actually go wrong.
10//
11// EVERYTHING IS READ FROM THE PINNED DOCUMENT, INCLUDING THE SECRET. RFC 4226 Appendix D states it as
12//     Secret = 0x3132333435363738393031323334353637383930
13// and typing those 20 bytes from memory would put the agent back in the byte path for the one input the
14// whole test depends on. ★THE KEY IS AN ANSWER TOO.
15//
16// ⚠ANCHOR HAZARD, HIT AND FIXED: Appendix D has TWO tables --
17//     Table 1: "Count    Hexadecimal HMAC-SHA-1(secret, count)"   (raw HMAC values)
18//     Table 2: "Count    Hexadecimal    Decimal        HOTP"       (truncated + HOTP)
19// Anchoring on "Count    Hexadecimal" matches TABLE 1 FIRST and would grade HOTP codes against 20-byte
20// HMAC strings. The anchor below is the full Table-2 header. ★AN ANCHOR THAT IS A PREFIX OF AN EARLIER
21// HEADING FINDS THE EARLIER ONE -- the same class as matching a table of contents instead of the body.
22//
23// Document pinned to a CORROBORATED digest (sovereign fetch and .NET WebClient independently agree --
24// knowledge/extvec/CORROBORATION.tsv).
25// license_tier: ORIGINAL  expect_exit: 0
26import "nx_syscalls.nx"
27import "nx_sha256_wasm.nx"
28import "nx_hotp_sha1.nx"
29import "nx_gate_verdict.nx"
30
31func w(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
32func wb(b: *u8, n: i64) -> i64 { sys_write(1, b, n); return 0 }
33
34func 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
46}
47
48func hexnib(v: i64) -> i64 { if v < 10 { return 48 + v } return 87 + v }
49func 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
54}
55func 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
61}
62func 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
70}
71func 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// Read a run of contiguous hex pairs (no whitespace tolerance -- the secret is one unbroken run).
78func parsehex(b: *u8, n: i64, from: i64, out: *u8, want: i64) -> i64 {
  var p: i64 = from
  var got: i64 = 0
  while got < want {
      if p + 1 >= n { return 0 - 1 }
      let h1: i64 = hexval(b[p] as i64)
      let h2: i64 = hexval(b[p + 1] as i64)
      if h1 < 0 { return 0 - 1 }
      if h2 < 0 { return 0 - 1 }
      out[got] = ((h1 * 16) + h2) as u8
      got = got + 1
      p = p + 2
  }
  return p
92}
93
94// Read the next whitespace-separated DECIMAL token starting at/after `p`. Returns the value; writes the
95// position just past the token into endp. -1 if the next token is not decimal.
96func next_dec(b: *u8, n: i64, p0: i64, endp: *i64) -> i64 {
  var p: i64 = p0
  var d: i64 = 0
  while d == 0 {
      if p >= n { return 0 - 1 }
      if isws(b[p] as i64) == 1 { p = p + 1 } else { d = 1 }
  }
  var v: i64 = 0
  var any: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if p >= n { done = 1 }
      else {
          let c: i64 = b[p] as i64
          if c >= 48 { if c <= 57 { v = v * 10 + (c - 48); any = 1; p = p + 1 } else { done = 1 } }
          else { done = 1 }
      }
  }
  if any == 0 { return 0 - 1 }
  endp[0] = p
  return v
117}
118
119// Skip one whitespace-separated token of ANY kind (used for the hex column, which is not decimal).
120func skip_token(b: *u8, n: i64, p0: i64) -> i64 {
  var p: i64 = p0
  var d: i64 = 0
  while d == 0 {
      if p >= n { return p }
      if isws(b[p] as i64) == 1 { p = p + 1 } else { d = 1 }
  }
  while p < n { if isws(b[p] as i64) == 1 { return p } p = p + 1 }
  return p
129}
130
131func main() -> i64 {
  w("nx_hotp_extvec_gate -- HOTP vs RFC 4226 Appendix D, READ FROM THE FETCHED DOCUMENT\n" as *u8)
133
  let lp: *i64 = sys_mmap(16) as *i64
  lp[0] = 0
  let b: *u8 = sys_read_file("knowledge/extvec/rfc4226.txt\x00" as *u8, lp)
  if lp[0] <= 0 { w("RED: fetched vector file absent -- run nx_vecfetch.\n" as *u8); return 1 }
138
  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 = "db6974cd02ca33560ec3a191ee9b1016067cd11d1f5d89e7efa36be69482229d\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 corroborated document.\n" as *u8); return 1 }
  w("  PIN OK -- CORROBORATED (sovereign fetch and .NET WebClient agree)\n" as *u8)
152
  // ---- the SECRET, read from the document ----
  let sat: i64 = findfrom(b, lp[0], "Secret = 0x" as *u8, 0)
  if sat < 0 { w("RED: no 'Secret = 0x' in the document\n" as *u8); return 1 }
  let secret: *u8 = sys_mmap(64)
  if parsehex(b, lp[0], sat + 11, secret, 20) < 0 { w("RED: secret short\n" as *u8); return 1 }
  // PARSE SELF-CHECK: RFC 4226's secret is the ASCII digits "12345678901234567890", so byte 0 must be
  // '1' and byte 19 '0'. A mis-read secret would fail every vector and look like a broken HOTP.
  // ★NAME THE READER BEFORE BLAMING THE SUBJECT.
  var sok: i64 = 0
  if secret[0] == (49 as u8) { if secret[19] == (48 as u8) { sok = 1 } }
  if sok == 0 { w("RED: PARSE SELF-CHECK FAILED -- secret is not the ASCII digit run; the READER.\n" as *u8); return 1 }
  w("  secret parsed: 20 bytes, ASCII digit run -- self-check OK\n\n" as *u8)
165
  // ---- Table 2 ----
  let tab: i64 = findfrom(b, lp[0], "Count    Hexadecimal    Decimal        HOTP" as *u8, 0)
  if tab < 0 { w("RED: Table 2 header not found\n" as *u8); return 1 }
  // move past the header line
  var p: i64 = tab
  var dh: i64 = 0
  while dh == 0 { if p >= lp[0] { dh = 1 } else { if b[p] == (10 as u8) { p = p + 1; dh = 1 } else { p = p + 1 } } }
173
  let ep: *i64 = sys_mmap(16) as *i64
  var pass: i64 = 0
  var fail: i64 = 0
  var seen: i64 = 0
178
  var row: i64 = 0
  while row < 10 {
      ep[0] = 0
      let cnt: i64 = next_dec(b, lp[0], p, ep)
      if cnt < 0 { row = 10 }
      else {
          p = ep[0]
          p = skip_token(b, lp[0], p)          // hexadecimal column (not decimal)
          ep[0] = 0
          let dec: i64 = next_dec(b, lp[0], p, ep)   // decimal column
          if dec < 0 { row = 10 }
          else {
              p = ep[0]
              ep[0] = 0
              let want: i64 = next_dec(b, lp[0], p, ep)  // HOTP column
              if want < 0 { row = 10 }
              else {
                  p = ep[0]
                  let got: i64 = hotp_sha1_code(secret, 20, cnt, 6)
                  seen = seen + 1
                  if got == want {
                      pass = pass + 1
                      w("  PASS count=" as *u8); nn(cnt); w("  HOTP=" as *u8); nn(want); w("\n" as *u8)
                  } else {
                      fail = fail + 1
                      w("  FAIL count=" as *u8); nn(cnt); w("  expected " as *u8); nn(want)
                      w(" got " as *u8); nn(got); w("\n" as *u8)
                  }
                  row = row + 1
              }
          }
      }
  }
212
  // RFC 4226 publishes TEN. Grading fewer while printing GREEN is coverage-gaming.
  if seen < 10 {
      w("\n  RED: only " as *u8); nn(seen); w(" of 10 published values graded -- refusing GREEN on a partial read.\n" as *u8)
      fail = fail + 1
  }
218
  w("\n  refsrc=https://www.rfc-editor.org/rfc/rfc4226.txt\n" as *u8)
  w("  refsrcdig=" as *u8); wb(hx, 64); w("\n" as *u8)
  w("  ref=RFC4226-AppendixD-Table2   gate=nx_hotp_extvec_gate\n" as *u8)
  w("  BOUND: nx_hotp_sha1.nx -> nx_hmac_sha1.nx -> nx_sha1.nx  (the repaired family)\n" as *u8)
  w("nx_hotp_extvec_gate: values=" 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("HOTP-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
234}
nx_hotp_extvec_gate.nx source

`nx_hotp_extvec_gate.nx` source
