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

↩ module page · 228 lines · 10933 B
1// nx_modauth_e2e_gate.nx -- ENGINEER gate: the WHOLE modern-auth login stack end to end.
2//
3// Composes the real production path the wiki daemon will call: server key bundle
4// (load-or-init, idempotent) -> nx_modern_auth_register (OPAQUE registration +
5// argon2id KSF + additive-only store) -> nx_modern_auth_login (OPAQUE-3DH KE1/KE2/KE3
6// + ServerFinish + Ed25519 session mint) -> nx_modern_auth_validate_session.
7//
8// 14 rows:
9//   1 keygen idempotent (second load == first)        6 tampered token rejected
10//   2 register OK + 24-word BIP39 mnemonic issued     7 expired token rejected
11//   3 login correct pw -> 152B token                  8 re-register supersedes (old pw dies)
12//   4 token validates + user_id_hash matches          9 new pw lives after supersede
13//   5 wrong pw -> WRONG_PASSPHRASE                   10 unknown user -> USER_NOT_FOUND
14//  11 recover w/ mnemonic -> OK + NEW rotated mnemonic
15//  12 login with recovered passphrase -> OK (and pre-recover pw dead)
16//  13 recover with the OLD mnemonic after rotation -> RECOVERY_MISMATCH
17//  14 recover with a typo'd mnemonic (checksum) -> RECOVERY_MISMATCH
18//
19// KSF here: argon2id m=8 MiB t=1 (real memory-hard path, gate-speed params).
20// Production realm ctx uses vault-lineage 32 MiB / t=3. Recovery credential = KSF
21// Identity by design (256-bit CSPRNG entropy; no dictionary to defend against).
22// license_tier: ORIGINAL
23import "hub/nx_modern_auth_flow.nx"
24import "nx_syscalls.nx"
25
26func eg_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
27func eg_row(idx: i64, ok: i64, name: *u8) -> i64 {
  if ok == 1 { eg_w("ROW " as *u8) }
  if ok != 1 { eg_w("FAIL " as *u8) }
  let d: *u8 = sys_mmap(4)
  d[0] = (48 + (idx / 10)) as u8
  d[1] = (48 + (idx % 10)) as u8
  d[2] = 32 as u8
  sys_write(1, d, 3)
  eg_w(name)
  eg_w("\n" as *u8)
  if ok == 1 { return 1 }
  return 0
39}
40func eg_eq(a: *u8, b: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { if (a[i] as i64) != (b[i] as i64) { return 0 } i = i + 1 }
  return 1
44}
45func eg_trunc(path: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x180)
  if fd >= 0 { sys_close(fd) }
  return 0
49}
50
51func main() -> i64 {
  let store_path: *u8 = "/tmp/nishi_mauth_gate_store.log" as *u8
  let keys_path: *u8 = "/tmp/nishi_mauth_gate_keys.log" as *u8
  eg_trunc(store_path)
  eg_trunc(keys_path)
  var pass: i64 = 0
57
  // ---- row 1: server key bundle load-or-init, idempotent ----
  let oprf_seed: *u8 = sys_mmap(32)
  let akp: *u8 = sys_mmap(32)
  let akb: *u8 = sys_mmap(33)
  let edp: *u8 = sys_mmap(32)
  let edb: *u8 = sys_mmap(32)
  var r1: i64 = 0
  if nx_uas_server_keys_load_or_init(keys_path, oprf_seed, akp, akb, edp, edb) == NX_UAS_OK {
      let o2: *u8 = sys_mmap(32)
      let a2: *u8 = sys_mmap(32)
      let b2: *u8 = sys_mmap(33)
      let e2: *u8 = sys_mmap(32)
      let f2: *u8 = sys_mmap(32)
      if nx_uas_server_keys_load_or_init(keys_path, o2, a2, b2, e2, f2) == NX_UAS_OK {
          if eg_eq(oprf_seed, o2, 32) == 1 { if eg_eq(edp, e2, 32) == 1 { r1 = 1 } }
      }
  }
  pass = pass + eg_row(1, r1, "server-keys load-or-init idempotent" as *u8)
76
  // ---- auth context (the wiki realm shape) ----
  let realm: *u8 = "nishi_wiki_admin" as *u8
  let disp: *u8 = "Nishi wiki admin" as *u8
  let ctx: *NxAuthContext = sys_mmap(256) as *NxAuthContext
  let rc_ctx: i64 = nx_auth_context_init(ctx, realm, 16, disp, 16,
                                             store_path as i64, oprf_seed, edp, edb,
                                             900, 8192, 1, 1, 5, 1)
  if rc_ctx != NX_MAUTH_OK { eg_w("CTX-INIT FAILED\n" as *u8); sys_exit(1) }
85
  let handle: *u8 = "elder" as *u8
  let pw: *u8 = "correct horse battery staple" as *u8
  let pw_n: i64 = 28
  let pw2: *u8 = "rotated passphrase 2026" as *u8
  let pw2_n: i64 = 23
91
  // ---- row 2: register + 24-word mnemonic issued ----
  let mn: *u8 = sys_mmap(512)
  let mn_n: *i64 = sys_mmap(16) as *i64
  var r2: i64 = 0
  if nx_modern_auth_register(ctx, handle, 5, pw, pw_n, mn, 512, mn_n) == NX_MAUTH_OK {
      if mn_n[0] > 0 {
          // 24 words = 23 spaces
          var sp: i64 = 0
          var si: i64 = 0
          while si < mn_n[0] { if (mn[si] as i64) == 32 { sp = sp + 1 } si = si + 1 }
          if sp == 23 { r2 = 1 }
      }
  }
  pass = pass + eg_row(2, r2, "register stores record + issues 24-word mnemonic" as *u8)
106
  // ---- row 3: login correct passphrase ----
  let tok: *u8 = sys_mmap(NX_MAUTH_SESSION_TOKEN_BYTES)
  let tok_n: *i64 = sys_mmap(16) as *i64
  var r3: i64 = 0
  if nx_modern_auth_login(ctx, handle, 5, pw, pw_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == NX_MAUTH_OK {
      if tok_n[0] == NX_MAUTH_SESSION_TOKEN_BYTES { r3 = 1 }
  }
  pass = pass + eg_row(3, r3, "login correct pw -> 152B session token" as *u8)
115
  // ---- row 4: token validates, user hash matches ----
  let now_s: i64 = sys_now_realtime_sec()
  let uh: *u8 = sys_mmap(32)
  let uh_n: *i64 = sys_mmap(16) as *i64
  var r4: i64 = 0
  if nx_modern_auth_validate_session(ctx, tok, NX_MAUTH_SESSION_TOKEN_BYTES, now_s, uh, 32, uh_n) == NX_MAUTH_OK {
      let want_uh: *u8 = sys_mmap(32)
      nx_ncs_derive_user_id_hash(realm, 16, handle, 5, want_uh)
      if eg_eq(uh, want_uh, 32) == 1 { r4 = 1 }
  }
  pass = pass + eg_row(4, r4, "session validates + user_id_hash matches" as *u8)
127
  // ---- row 5: wrong passphrase rejected ----
  let bad_pw: *u8 = "incorrect horse battery stap" as *u8
  var r5: i64 = 0
  if nx_modern_auth_login(ctx, handle, 5, bad_pw, pw_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == (0 - NX_MAUTH_WRONG_PASSPHRASE) { r5 = 1 }
  pass = pass + eg_row(5, r5, "wrong pw -> WRONG_PASSPHRASE" as *u8)
133
  // ---- row 6: tampered token rejected ----
  let tok2: *u8 = sys_mmap(NX_MAUTH_SESSION_TOKEN_BYTES)
  let tok2_n: *i64 = sys_mmap(16) as *i64
  nx_modern_auth_login(ctx, handle, 5, pw, pw_n, tok2, NX_MAUTH_SESSION_TOKEN_BYTES, tok2_n)
  tok2[100] = ((tok2[100] as i64) ^ 1) as u8
  var r6: i64 = 0
  if nx_modern_auth_validate_session(ctx, tok2, NX_MAUTH_SESSION_TOKEN_BYTES, now_s, 0 as *u8, 0, uh_n) == (0 - NX_MAUTH_INVALID_SESSION) { r6 = 1 }
  pass = pass + eg_row(6, r6, "tampered token -> INVALID_SESSION" as *u8)
142
  // ---- row 7: expired token rejected ----
  let tok3: *u8 = sys_mmap(NX_MAUTH_SESSION_TOKEN_BYTES)
  let tok3_n: *i64 = sys_mmap(16) as *i64
  nx_modern_auth_login(ctx, handle, 5, pw, pw_n, tok3, NX_MAUTH_SESSION_TOKEN_BYTES, tok3_n)
  var r7: i64 = 0
  if nx_modern_auth_validate_session(ctx, tok3, NX_MAUTH_SESSION_TOKEN_BYTES, now_s + 901, 0 as *u8, 0, uh_n) == (0 - NX_MAUTH_EXPIRED) { r7 = 1 }
  pass = pass + eg_row(7, r7, "expired token -> EXPIRED" as *u8)
150
  // ---- row 8+9: re-register supersedes (additive-only) ----
  // (also rotates the mnemonic; the post-re-register one is what rows 11-13 use)
  nx_modern_auth_register(ctx, handle, 5, pw2, pw2_n, mn, 512, mn_n)
  var r8: i64 = 0
  if nx_modern_auth_login(ctx, handle, 5, pw, pw_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == (0 - NX_MAUTH_WRONG_PASSPHRASE) { r8 = 1 }
  pass = pass + eg_row(8, r8, "re-register supersedes: old pw rejected" as *u8)
  var r9: i64 = 0
  if nx_modern_auth_login(ctx, handle, 5, pw2, pw2_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == NX_MAUTH_OK { r9 = 1 }
  pass = pass + eg_row(9, r9, "new pw accepted after supersede" as *u8)
160
  // ---- row 10: unknown user ----
  let ghost: *u8 = "ghost" as *u8
  var r10: i64 = 0
  if nx_modern_auth_login(ctx, ghost, 5, pw, pw_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == (0 - NX_MAUTH_USER_NOT_FOUND) { r10 = 1 }
  pass = pass + eg_row(10, r10, "unknown user -> USER_NOT_FOUND" as *u8)
166
  // ---- row 11: recover with the current mnemonic -> OK + rotated mnemonic ----
  let pw3: *u8 = "recovered passphrase three" as *u8
  let pw3_n: i64 = 26
  let mn2: *u8 = sys_mmap(512)
  let mn2_n: *i64 = sys_mmap(16) as *i64
  var r11: i64 = 0
  if nx_modern_auth_recover(ctx, handle, 5, mn, mn_n[0], pw3, pw3_n, mn2, 512, mn2_n) == NX_MAUTH_OK {
      if mn2_n[0] > 0 {
          var same: i64 = 0
          if mn2_n[0] == mn_n[0] { same = eg_eq(mn2, mn, mn_n[0]) }
          if same == 0 { r11 = 1 }
      }
  }
  pass = pass + eg_row(11, r11, "recover w/ mnemonic -> new pw set + mnemonic ROTATED" as *u8)
181
  // ---- row 12: login with recovered passphrase; pre-recover pw dead ----
  var r12: i64 = 0
  if nx_modern_auth_login(ctx, handle, 5, pw3, pw3_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == NX_MAUTH_OK {
      if nx_modern_auth_login(ctx, handle, 5, pw2, pw2_n, tok, NX_MAUTH_SESSION_TOKEN_BYTES, tok_n) == (0 - NX_MAUTH_WRONG_PASSPHRASE) { r12 = 1 }
  }
  pass = pass + eg_row(12, r12, "recovered pw lives, pre-recover pw dead" as *u8)
188
  // ---- row 13: OLD mnemonic after rotation -> RECOVERY_MISMATCH ----
  var r13: i64 = 0
  if nx_modern_auth_recover(ctx, handle, 5, mn, mn_n[0], pw3, pw3_n, mn2, 512, mn2_n) == (0 - NX_MAUTH_RECOVERY_MISMATCH) { r13 = 1 }
  pass = pass + eg_row(13, r13, "old mnemonic after rotation -> RECOVERY_MISMATCH" as *u8)
193
  // ---- row 14: typo'd mnemonic (bad checksum) -> RECOVERY_MISMATCH ----
  let mn_typo: *u8 = sys_mmap(512)
  var ti: i64 = 0
  while ti < mn2_n[0] { mn_typo[ti] = mn2[ti]; ti = ti + 1 }
  // overwrite the first word with "zoo " padding-safe: just flip first letter to make
  // a DIFFERENT valid-or-invalid word start; simplest deterministic typo = swap first
  // word entirely by writing "zoo" + original tail from the first space.
  var sp1: i64 = 0
  var sscan: i64 = 1
  while sscan == 1 {
      if sp1 >= mn2_n[0] { sscan = 0 }
      if sscan == 1 { if (mn_typo[sp1] as i64) == 32 { sscan = 0 } }
      if sscan == 1 { sp1 = sp1 + 1 }
  }
  // build "zoo" || tail
  let typo2: *u8 = sys_mmap(512)
  typo2[0] = 0x7A as u8; typo2[1] = 0x6F as u8; typo2[2] = 0x6F as u8
  var tj: i64 = 0
  while sp1 + tj < mn2_n[0] { typo2[3 + tj] = mn_typo[sp1 + tj]; tj = tj + 1 }
  let typo2_n: i64 = 3 + tj
  var r14: i64 = 0
  var rc14: i64 = nx_modern_auth_recover(ctx, handle, 5, typo2, typo2_n, pw3, pw3_n, mn2, 512, mn2_n)
  if rc14 == (0 - NX_MAUTH_RECOVERY_MISMATCH) { r14 = 1 }
  // (1/256 chance the forged checksum still passes BIP39 but then OPAQUE rejects ->
  //  also RECOVERY_MISMATCH, so the assert is deterministic either way)
  pass = pass + eg_row(14, r14, "typo'd mnemonic -> RECOVERY_MISMATCH" as *u8)
220
  if pass == 14 {
      eg_w("MODAUTH E2E GATE GREEN 14/14 (OPAQUE register/login/RECOVER + BIP39 rotate + argon2id KSF + store + session mint/validate)\n" as *u8)
      sys_exit(0)
  }
  eg_w("MODAUTH E2E GATE RED\n" as *u8)
  sys_exit(1)
  return 1
228}
nx_modauth_e2e_gate.nx source

`nx_modauth_e2e_gate.nx` source
