`nx_md5.nx` source

↩ module page · 246 lines · 9362 B
1// nx_md5.nx -- MD5 message digest (RFC 1321).
2//
3// MD5 is cryptographically broken (collisions) but still used for:
4//   - Legacy file checksums (md5sum verification)
5//   - Apache .htdigest auth files (which we may need to interop)
6//   - ETag generation (when collision resistance isn't needed)
7//   - Cache keys for systems that hardcode 16-byte digests
8//
9// DO NOT use MD5 for passwords, signatures, or anything where an
10// attacker controls the input.  Use SHA-256 (already in tree) +
11// HMAC.
12//
13// Algorithm: 64-round MD-construction with 4-word state, processing
14// 64-byte blocks.  Returns 16-byte digest.
15
16// nx_safety_envelope:
17//   intended_use:       AUTO_APPLIED -- primitive-specific tuning queued
18//   sil_target:         SIL1
19//   evidence:           [bulk_applied_2026-05-16, see-file-comment-for-detail]
20//   verdict:            NOT_YET_EVALUATED
21
22import "syscalls.nx"
23
24// 64-bit rotate-left for 32-bit values (MD5 ops are 32-bit).
25func nx_md5_rotl(x: i64, k: i64) -> i64 {
  let v: i64 = x & 0xFFFFFFFF
  let lo: i64 = (v << k) & 0xFFFFFFFF
  let hi: i64 = (v >> (32 - k)) & ((1 << (32 - k)) - 1)
  return (lo | hi) & 0xFFFFFFFF
30}
31
32// MD5 round functions.  Each operates on 32-bit words.
33func nx_md5_F(x: i64, y: i64, z: i64) -> i64 { return ((x & y) | ((~x) & z)) & 0xFFFFFFFF }
34func nx_md5_G(x: i64, y: i64, z: i64) -> i64 { return ((x & z) | (y & (~z))) & 0xFFFFFFFF }
35func nx_md5_H(x: i64, y: i64, z: i64) -> i64 { return (x ^ y ^ z) & 0xFFFFFFFF }
36func nx_md5_I(x: i64, y: i64, z: i64) -> i64 { return (y ^ (x | (~z))) & 0xFFFFFFFF }
37
38// FF/GG/HH/II step macros.
39func nx_md5_FF(a: i64, b: i64, c: i64, d: i64, m: i64, s: i64, t: i64) -> i64 {
  let v: i64 = (a + nx_md5_F(b, c, d) + m + t) & 0xFFFFFFFF
  return (b + nx_md5_rotl(v, s)) & 0xFFFFFFFF
42}
43func nx_md5_GG(a: i64, b: i64, c: i64, d: i64, m: i64, s: i64, t: i64) -> i64 {
  let v: i64 = (a + nx_md5_G(b, c, d) + m + t) & 0xFFFFFFFF
  return (b + nx_md5_rotl(v, s)) & 0xFFFFFFFF
46}
47func nx_md5_HH(a: i64, b: i64, c: i64, d: i64, m: i64, s: i64, t: i64) -> i64 {
  let v: i64 = (a + nx_md5_H(b, c, d) + m + t) & 0xFFFFFFFF
  return (b + nx_md5_rotl(v, s)) & 0xFFFFFFFF
50}
51func nx_md5_II(a: i64, b: i64, c: i64, d: i64, m: i64, s: i64, t: i64) -> i64 {
  let v: i64 = (a + nx_md5_I(b, c, d) + m + t) & 0xFFFFFFFF
  return (b + nx_md5_rotl(v, s)) & 0xFFFFFFFF
54}
55
56// Read u32 LE from byte buffer.
57func nx_md5_load_u32(p: *u8) -> i64 {
  return (p[0] as i64)
       | ((p[1] as i64) << 8)
       | ((p[2] as i64) << 16)
       | ((p[3] as i64) << 24)
62}
63
64// Process one 64-byte block, updating state[0..4].
65func nx_md5_block(state: *i64, blk: *u8) -> i64 {
  var a: i64 = state[0]
  var b: i64 = state[1]
  var c: i64 = state[2]
  var d: i64 = state[3]
70
  // Load 16 message words (LE).
  let m_raw: *u8 = sys_mmap(64)
  let m: *i64 = m_raw as *i64
  var i: i64 = 0
  while i < 16 {
      let p: *u8 = (((blk as i64) + i * 4) as *u8)
      m[i] = nx_md5_load_u32(p)
      i = i + 1
  }
80
  // Round 1
  a = nx_md5_FF(a, b, c, d, m[0],  7, 0xD76AA478)
  d = nx_md5_FF(d, a, b, c, m[1],  12, 0xE8C7B756)
  c = nx_md5_FF(c, d, a, b, m[2],  17, 0x242070DB)
  b = nx_md5_FF(b, c, d, a, m[3],  22, 0xC1BDCEEE)
  a = nx_md5_FF(a, b, c, d, m[4],  7, 0xF57C0FAF)
  d = nx_md5_FF(d, a, b, c, m[5],  12, 0x4787C62A)
  c = nx_md5_FF(c, d, a, b, m[6],  17, 0xA8304613)
  b = nx_md5_FF(b, c, d, a, m[7],  22, 0xFD469501)
  a = nx_md5_FF(a, b, c, d, m[8],  7, 0x698098D8)
  d = nx_md5_FF(d, a, b, c, m[9],  12, 0x8B44F7AF)
  c = nx_md5_FF(c, d, a, b, m[10], 17, 0xFFFF5BB1)
  b = nx_md5_FF(b, c, d, a, m[11], 22, 0x895CD7BE)
  a = nx_md5_FF(a, b, c, d, m[12], 7, 0x6B901122)
  d = nx_md5_FF(d, a, b, c, m[13], 12, 0xFD987193)
  c = nx_md5_FF(c, d, a, b, m[14], 17, 0xA679438E)
  b = nx_md5_FF(b, c, d, a, m[15], 22, 0x49B40821)
98
  // Round 2
  a = nx_md5_GG(a, b, c, d, m[1],  5, 0xF61E2562)
  d = nx_md5_GG(d, a, b, c, m[6],  9, 0xC040B340)
  c = nx_md5_GG(c, d, a, b, m[11], 14, 0x265E5A51)
  b = nx_md5_GG(b, c, d, a, m[0],  20, 0xE9B6C7AA)
  a = nx_md5_GG(a, b, c, d, m[5],  5, 0xD62F105D)
  d = nx_md5_GG(d, a, b, c, m[10], 9, 0x02441453)
  c = nx_md5_GG(c, d, a, b, m[15], 14, 0xD8A1E681)
  b = nx_md5_GG(b, c, d, a, m[4],  20, 0xE7D3FBC8)
  a = nx_md5_GG(a, b, c, d, m[9],  5, 0x21E1CDE6)
  d = nx_md5_GG(d, a, b, c, m[14], 9, 0xC33707D6)
  c = nx_md5_GG(c, d, a, b, m[3],  14, 0xF4D50D87)
  b = nx_md5_GG(b, c, d, a, m[8],  20, 0x455A14ED)
  a = nx_md5_GG(a, b, c, d, m[13], 5, 0xA9E3E905)
  d = nx_md5_GG(d, a, b, c, m[2],  9, 0xFCEFA3F8)
  c = nx_md5_GG(c, d, a, b, m[7],  14, 0x676F02D9)
  b = nx_md5_GG(b, c, d, a, m[12], 20, 0x8D2A4C8A)
116
  // Round 3
  a = nx_md5_HH(a, b, c, d, m[5],  4, 0xFFFA3942)
  d = nx_md5_HH(d, a, b, c, m[8],  11, 0x8771F681)
  c = nx_md5_HH(c, d, a, b, m[11], 16, 0x6D9D6122)
  b = nx_md5_HH(b, c, d, a, m[14], 23, 0xFDE5380C)
  a = nx_md5_HH(a, b, c, d, m[1],  4, 0xA4BEEA44)
  d = nx_md5_HH(d, a, b, c, m[4],  11, 0x4BDECFA9)
  c = nx_md5_HH(c, d, a, b, m[7],  16, 0xF6BB4B60)
  b = nx_md5_HH(b, c, d, a, m[10], 23, 0xBEBFBC70)
  a = nx_md5_HH(a, b, c, d, m[13], 4, 0x289B7EC6)
  d = nx_md5_HH(d, a, b, c, m[0],  11, 0xEAA127FA)
  c = nx_md5_HH(c, d, a, b, m[3],  16, 0xD4EF3085)
  b = nx_md5_HH(b, c, d, a, m[6],  23, 0x04881D05)
  a = nx_md5_HH(a, b, c, d, m[9],  4, 0xD9D4D039)
  d = nx_md5_HH(d, a, b, c, m[12], 11, 0xE6DB99E5)
  c = nx_md5_HH(c, d, a, b, m[15], 16, 0x1FA27CF8)
  b = nx_md5_HH(b, c, d, a, m[2],  23, 0xC4AC5665)
134
  // Round 4
  a = nx_md5_II(a, b, c, d, m[0],  6, 0xF4292244)
  d = nx_md5_II(d, a, b, c, m[7],  10, 0x432AFF97)
  c = nx_md5_II(c, d, a, b, m[14], 15, 0xAB9423A7)
  b = nx_md5_II(b, c, d, a, m[5],  21, 0xFC93A039)
  a = nx_md5_II(a, b, c, d, m[12], 6, 0x655B59C3)
  d = nx_md5_II(d, a, b, c, m[3],  10, 0x8F0CCC92)
  c = nx_md5_II(c, d, a, b, m[10], 15, 0xFFEFF47D)
  b = nx_md5_II(b, c, d, a, m[1],  21, 0x85845DD1)
  a = nx_md5_II(a, b, c, d, m[8],  6, 0x6FA87E4F)
  d = nx_md5_II(d, a, b, c, m[15], 10, 0xFE2CE6E0)
  c = nx_md5_II(c, d, a, b, m[6],  15, 0xA3014314)
  b = nx_md5_II(b, c, d, a, m[13], 21, 0x4E0811A1)
  a = nx_md5_II(a, b, c, d, m[4],  6, 0xF7537E82)
  d = nx_md5_II(d, a, b, c, m[11], 10, 0xBD3AF235)
  c = nx_md5_II(c, d, a, b, m[2],  15, 0x2AD7D2BB)
  b = nx_md5_II(b, c, d, a, m[9],  21, 0xEB86D391)
152
  state[0] = (state[0] + a) & 0xFFFFFFFF
  state[1] = (state[1] + b) & 0xFFFFFFFF
  state[2] = (state[2] + c) & 0xFFFFFFFF
  state[3] = (state[3] + d) & 0xFFFFFFFF
  return 0
158}
159
160// Compute MD5 of `n` bytes from `data` into 16-byte `digest`.
161func nx_md5(data: *u8, n: i64, digest: *u8) -> i64 {
  let state_raw: *u8 = sys_mmap(32)
  let state: *i64 = state_raw as *i64
  state[0] = 0x67452301
  state[1] = 0xEFCDAB89
  state[2] = 0x98BADCFE
  state[3] = 0x10325476
168
  var off: i64 = 0
  while off + 64 <= n {
      let p: *u8 = (((data as i64) + off) as *u8)
      nx_md5_block(state, p)
      off = off + 64
  }
175
  // Padding: 0x80 byte, then zeros, then length in bits as 8-byte LE.
  let pad: *u8 = sys_mmap(128)
  var pad_len: i64 = 0
  let tail: i64 = n - off
  var i: i64 = 0
  while i < tail {
      pad[i] = data[off + i]
      i = i + 1
  }
  pad[tail] = 0x80
  pad_len = tail + 1
  // Pad with zeros until we land at length-mod-64 == 56.
  var pad_done: i64 = 0
  while pad_done == 0 {
      let mod: i64 = pad_len & 63
      if mod == 56 { pad_done = 1 }
      else { pad[pad_len] = 0; pad_len = pad_len + 1 }
  }
  // Append 64-bit bit-length LE.
  let bits: i64 = n * 8
  pad[pad_len + 0] = bits & 0xFF
  pad[pad_len + 1] = (bits >> 8) & 0xFF
  pad[pad_len + 2] = (bits >> 16) & 0xFF
  pad[pad_len + 3] = (bits >> 24) & 0xFF
  pad[pad_len + 4] = (bits >> 32) & 0xFF
  pad[pad_len + 5] = (bits >> 40) & 0xFF
  pad[pad_len + 6] = (bits >> 48) & 0xFF
  pad[pad_len + 7] = (bits >> 56) & 0xFF
  pad_len = pad_len + 8
205
  var po: i64 = 0
  while po < pad_len {
      let p: *u8 = (((pad as i64) + po) as *u8)
      nx_md5_block(state, p)
      po = po + 64
  }
212
  // Output digest LE.
  var k: i64 = 0
  while k < 4 {
      digest[k * 4 + 0] = state[k] & 0xFF
      digest[k * 4 + 1] = (state[k] >> 8) & 0xFF
      digest[k * 4 + 2] = (state[k] >> 16) & 0xFF
      digest[k * 4 + 3] = (state[k] >> 24) & 0xFF
      k = k + 1
  }
  return 0
223}
224
225// ---- self-test ---------------------------------------------------
226
227func main() -> i64 {
  let digest: *u8 = sys_mmap(16)
229
  // MD5("") = D41D8CD98F00B204E9800998ECF8427E
  let empty: *u8 = sys_mmap(8)
  nx_md5(empty, 0, digest)
  if digest[0]  != 0xD4 { return __syscall(93, 1, 0, 0, 0, 0, 0) }
  if digest[1]  != 0x1D { return __syscall(93, 2, 0, 0, 0, 0, 0) }
  if digest[15] != 0x7E { return __syscall(93, 3, 0, 0, 0, 0, 0) }
236
  // MD5("abc") = 900150983CD24FB0D6963F7D28E17F72
  let abc: *u8 = sys_mmap(8)
  abc[0] = 0x61; abc[1] = 0x62; abc[2] = 0x63
  nx_md5(abc, 3, digest)
  if digest[0]  != 0x90 { return __syscall(93, 4, 0, 0, 0, 0, 0) }
  if digest[1]  != 0x01 { return __syscall(93, 5, 0, 0, 0, 0, 0) }
  if digest[15] != 0x72 { return __syscall(93, 6, 0, 0, 0, 0, 0) }
244
  return 0
246}
nx_md5.nx source

`nx_md5.nx` source
