`nx_acme_http.nx` source

↩ module page · 362 lines · 16688 B
1// nx_acme_http.nx -- reusable ACME transport + tiny JSON string reader.
2//
3// One ACME request = fresh TLS 1.3 connection (LE supports keep-alive but
4// one-shot connections are simplest + robust): url_for_fetch -> url_connect
5// -> session_run (validates the chain via the trust store) -> get/post_
6// complete -> raw response bytes.  The caller parses status/headers/body
7// with nx_http_response_parse + nx_http_response_header + nx_acme_json_str.
8//
9// Composes the proven live-HTTPS stack (same path as the example.com smoke,
10// now reaching LE after the RSA-4096 chain-verify fix).
11//
12// license_tier: ORIGINAL (composes the shipped TLS client + HTTP parser)
13
14import "nx_syscalls.nx"
15import "nx_x509_trust_store.nx"
16import "nx_trust_store_load_from_certdata.nx"
17import "nx_tls13_client_validate_certificate.nx"
18import "nx_tls13_client_session_run.nx"
19import "nx_tls12_client_session.nx"   // TLS 1.2 fallback session (api.porkbun.com is TLS-1.2-max)
20import "nx_https_url_for_fetch.nx"
21import "nx_https_url_connect.nx"
22import "nx_https_get_complete.nx"
23import "nx_https_post_complete.nx"
24import "nx_http_client.nx"            // request builders reused for the 1.2 round trip
25import "nx_http_response_parse.nx"
26import "nx_csprng.nx"
27const NX_MAGIC_8192: i64 = 8192
28const NX_MAGIC_20000: i64 = 20000
29const NX_MAGIC_4194304: i64 = 4194304
30const NX_MAGIC_1779284141: i64 = 1779284141
31const NX_MAGIC_65536: i64 = 65536
32const NX_MAGIC_16384: i64 = 16384
33
34const NX_ACME_HTTP_OK:          i64 = 0
35const NX_ACME_HTTP_URL_FAIL:    i64 = 0 - 1
36const NX_ACME_HTTP_CONNECT_FAIL: i64 = 0 - 2
37const NX_ACME_HTTP_TLS_FAIL:    i64 = 0 - 3
38const NX_ACME_HTTP_IO_FAIL:     i64 = 0 - 4
39
40// TLS 1.2 fallback reconnect-retry budget (defense-in-depth for the rapid
41// 1.3->1.2 reconnect). A transient incomplete first flight (-READ_FLIGHT) or
42// a garbled ServerHello (-UNSUPPORTED_CIPHER) FAILS CLOSED (no session); we
43// self-heal by closing + reconnecting + re-handshaking with FRESH entropy.
44// 3 tries covers a transient that clears within a couple hundred ms; a real
45// outage still terminates (bounded loop, never hangs). Tunable here, not
46// buried in the loop body (no magic numbers).
47const NX_ACME_TLS12_MAX_TRIES:        i64 = 3
48const NX_ACME_TLS12_RETRY_SETTLE_MS:  i64 = 150
49
50// --- TLS 1.2 fallback round trip ---------------------------------------
51// Carry ONE HTTP request/response over an ALREADY-established TLS 1.2
52// session (api.porkbun.com negotiates TLS 1.2 MAXIMUM, so the 1.3 path
53// gets a version-negotiation alert and we retry over 1.2 here). Builds the
54// SAME HTTP/1.1 request the 1.3 helpers build, sends it as one encrypted
55// application_data record, and drains the encrypted response (app-data
56// accumulated; a TLS alert / close_notify / EOF ends it) into out_buf.
57// Returns POSITIVE bytes accumulated, or NEGATIVE -NX_ACME_HTTP_IO_FAIL.
58func _acme_http12_roundtrip(
  s: *Tls12ClientSession, fd: i64,
  post: i64,
  path: *u8, path_len: i64,
  host: *u8, host_len: i64,
  content_type: *u8, content_type_len: i64,
  body: *u8, body_len: i64,
  out_buf: *u8, out_cap: i64
66) -> i64 {
  // Build the request via the shipped HTTP/1.1 request builders.
  let req: *u8 = sys_mmap(body_len + NX_MAGIC_8192)
  var req_len: i64 = 0
  if post == 1 {
      req_len = nx_http_client_build_request_post(
          path, path_len, host, host_len,
          content_type, content_type_len, body, body_len, req)
  } else {
      req_len = nx_http_client_build_request(path, path_len, host, host_len, req)
  }
  if req_len <= 0 { return 0 - NX_ACME_HTTP_IO_FAIL }
78
  // Send as one encrypted application_data record (client seq starts at 1).
  if nx_tls12_session_send(s, fd, req, req_len) != 0 { return 0 - NX_ACME_HTTP_IO_FAIL }
81
  // Drain encrypted response records until alert / close_notify / EOF.
  let pt: *u8 = sys_mmap(NX_MAGIC_20000)
  let ctp: *i64 = sys_mmap(16) as *i64
  var acc: i64 = 0
  var rounds: i64 = 0
  var draining: i64 = 1
  while draining == 1 {
      if rounds >= 256 { draining = 0 }
      else {
          let pl: i64 = nx_tls12_session_recv(s, fd, pt, NX_MAGIC_20000, ctp)
          rounds = rounds + 1
          if pl < 0 { draining = 0 }                  // EOF / decrypt error -> stop
          else {
              if ctp[0] == 23 {                       // application_data -> accumulate
                  var j: i64 = 0
                  while j < pl {
                      if acc < out_cap { out_buf[acc] = pt[j]; acc = acc + 1 }
                      j = j + 1
                  }
              }
              if ctp[0] == 21 { draining = 0 }        // alert (e.g. close_notify) -> stop
          }
      }
  }
  return acc
107}
108
109// Perform one ACME/HTTPS request over a fresh validated TLS session, with a
110// TLS 1.3 -> 1.2 version FALLBACK so the SAME transport reaches BOTH 1.3
111// hosts (e.g. acme-v02.api.letsencrypt.org) AND TLS-1.2-MAXIMUM hosts (e.g.
112// api.porkbun.com):
113//   1. Connect + try the shipped TLS 1.3 client. If it CONNECTS, run the
114//      1.3 GET/POST helper unchanged (no regression for Let's Encrypt).
115//   2. If 1.3 fails SPECIFICALLY at version negotiation -- the server is not
116//      1.3, so its first record is an alert/close_notify and reading or
117//      parsing the ServerHello fails (-READ_SH_FAIL / -RECV_SH_FAIL) -- the
118//      host is TLS-1.2-max: close the fd, reconnect TCP, and retry the
119//      sovereign TLS 1.2 client, carrying the request over the 1.2 session.
120//   Any OTHER 1.3 failure (cert/finished/decrypt/etc.) is a genuine error
121//   returned as -TLS_FAIL; we do NOT mask it with a 1.2 retry.
122//   post==1 -> POST with content_type + body; else GET.
123// Raw response (headers+body) lands in resp_buf; *out_total = byte count.
124// Handshake ephemerals (client_random + key-share scalar) are filled from
125// getrandom for EACH attempt so every connection has independent forward
126// secrecy (never hardcoded).
127func nx_acme_req(url: *u8, url_len: i64,
               post: i64,
               content_type: *u8, content_type_len: i64,
               body: *u8, body_len: i64,
               store: *TrustStore, now: i64,
               resp_buf: *u8, resp_cap: i64, out_total: *i64) -> i64 {
  let url_p: *NxUrl = nx_url_new()
  let target_raw: *u8 = sys_mmap(32)
  let target: *NxHttpsTarget = target_raw as *NxHttpsTarget
  target.url = url_p
  target.port = 0
  if nx_https_url_for_fetch(url, target) != NX_HTTPS_URL_OK { return NX_ACME_HTTP_URL_FAIL }
139
  let host: *u8 = (url as i64 + target.url.host_off) as *u8
  let host_len: i64 = target.url.host_len
  let path: *u8 = (url as i64 + target.url.path_off) as *u8
  let path_len: i64 = target.url.path_len
144
  // Validation context (trust store + SNI host + now) -- shared by both attempts.
  let vc_raw: *u8 = sys_mmap(64)
  let vc: *TlsValidationContext = vc_raw as *TlsValidationContext
  vc.store = store
  vc.sni_host = host
  vc.sni_host_len = host_len
  vc.now_epoch = now
152
  // ---- Attempt 1: TLS 1.3 (the existing, proven Let's Encrypt path) ----
  let fd_p: *i64 = sys_mmap(16) as *i64
  if nx_https_url_connect(target, url, now, fd_p) != NX_HTTPS_CONNECT_OK { return NX_ACME_HTTP_CONNECT_FAIL }
  var fd: i64 = *fd_p
157
  // fresh ephemeral handshake material (forward secrecy per connection)
  let cr: *u8 = sys_mmap(32)
  let priv: *u8 = sys_mmap(32)
  nx_csprng_fill(cr, 32)
  nx_csprng_fill(priv, 32)
163
  let sr: i64 = nx_tls13_client_session_run(fd, host, host_len, cr, priv, vc)
  if sr > 0 {
      let session: *Tls13ClientSession = sr as *Tls13ClientSession
      var total: i64 = 0
      if post == 1 {
          total = nx_https_post_complete(session, fd,
                                         path, path_len, host, host_len,
                                         content_type, content_type_len,
                                         body, body_len,
                                         resp_buf, resp_cap)
      } else {
          total = nx_https_get_complete(session, fd,
                                        path, path_len, host, host_len,
                                        resp_buf, resp_cap)
      }
      sys_close(fd)
      if total < 0 { return NX_ACME_HTTP_IO_FAIL }
      out_total[0] = total
      return NX_ACME_HTTP_OK
  }
184
  // 1.3 did not connect. Is this a VERSION-negotiation failure (=> retry
  // 1.2) or a genuine error (=> fail closed)?  The first-record alert /
  // ServerHello-read/parse failure is the only "wrong TLS version" symptom.
  // GRACEFUL teardown of the 1.3 socket (shutdown THEN close) so the
  // 1.3->1.2 transition starts from clean TCP state (rung 1: clean fd state
  // on reconnect). A bare close while the server's unread Certificate/SKE/
  // ServerHelloDone are still buffered aborts the connection with an RST
  // that races the immediately-following 1.2 SYN.
  sys_shutdown(fd, 2)
  sys_close(fd)
  var version_nego_fail: i64 = 0
  if sr == 0 - NX_TLS13_RUN_RECV_SH_FAIL { version_nego_fail = 1 }
  if sr == 0 - NX_TLS13_RUN_READ_SH_FAIL { version_nego_fail = 1 }
  if version_nego_fail == 0 { return NX_ACME_HTTP_TLS_FAIL }
199
  // ---- Attempt 2: TLS 1.2 fallback with bounded reconnect-RETRY ----
  // Each try is a FRESH TCP connection + FRESH handshake entropy (forward
  // secrecy preserved per attempt; a half-open socket is never reused). A
  // FAIL-CLOSED handshake on rapid reconnect -- incomplete first flight
  // (-READ_FLIGHT), a garbled/unsupported ServerHello (-UNSUPPORTED_CIPHER),
  // or a record error -- is treated as a TRANSIENT: shutdown+close, brief
  // settle, reconnect, re-handshake. The loop is BOUNDED so a real outage
  // terminates (never hangs); on success we leave the loop with fd12/sr12 live.
  var sr12: i64 = 0
  var fd12: i64 = 0 - 1
  var ok12: i64 = 0
  var tries: i64 = 0
  while tries < NX_ACME_TLS12_MAX_TRIES {
      tries = tries + 1
      if nx_https_url_connect(target, url, now, fd_p) != NX_HTTPS_CONNECT_OK {
          if tries < NX_ACME_TLS12_MAX_TRIES { sys_sleep_ms(NX_ACME_TLS12_RETRY_SETTLE_MS) }
      } else {
          fd12 = *fd_p
          sys_set_socket_timeout(fd12, 15)   // 1.2 cert chain is larger -> generous handshake budget
          let cr2: *u8 = sys_mmap(32)
          let seed2: *u8 = sys_mmap(32)
          nx_csprng_fill(cr2, 32)
          nx_csprng_fill(seed2, 32)
          let r12: i64 = nx_tls12_client_session_run(fd12, host, host_len, cr2, seed2, vc)
          if r12 > 0 {
              sr12 = r12
              ok12 = 1
              tries = NX_ACME_TLS12_MAX_TRIES        // success -> leave the retry loop
          } else {
              sys_shutdown(fd12, 2)
              sys_close(fd12)
              fd12 = 0 - 1
              if tries < NX_ACME_TLS12_MAX_TRIES { sys_sleep_ms(NX_ACME_TLS12_RETRY_SETTLE_MS) }
          }
      }
  }
  if ok12 == 0 {
      if fd12 >= 0 { sys_close(fd12) }
      return NX_ACME_HTTP_TLS_FAIL
  }
240
  let s12: *Tls12ClientSession = sr12 as *Tls12ClientSession
  let total12: i64 = _acme_http12_roundtrip(s12, fd12, post,
                                            path, path_len, host, host_len,
                                            content_type, content_type_len,
                                            body, body_len,
                                            resp_buf, resp_cap)
  sys_close(fd12)
  if total12 < 0 { return NX_ACME_HTTP_IO_FAIL }
  out_total[0] = total12
  return NX_ACME_HTTP_OK
251}
252
253// Find the FIRST occurrence of `"key":"<value>"` within buf[start..start+n]
254// and return the value's byte range.  Tolerant of whitespace around the
255// colon.  ACME top-level keys are unique, and ACME string values contain
256// no escaped quotes (URLs/tokens), so a plain scan to the next '"' is safe.
257// Returns 1 if found (out_off/out_len set), 0 otherwise.
258func nx_acme_json_str(buf: *u8, start: i64, n: i64,
                    key: *u8, key_len: i64,
                    out_off: *i64, out_len: *i64) -> i64 {
  let end: i64 = start + n
  var i: i64 = start
  while i < end {
      if buf[i] == 0x22 {                              // opening quote of a key
          var m: i64 = 1
          var k: i64 = 0
          while k < key_len {
              if (i + 1 + k) >= end { m = 0; break }
              if buf[i + 1 + k] != key[k] { m = 0; break }
              k = k + 1
          }
          if m == 1 {
              if (i + 1 + key_len) < end {
                  if buf[i + 1 + key_len] == 0x22 {    // closing quote of key
                      var colon: i64 = 0 - 1
                      var c: i64 = i + 2 + key_len
                      while c < end {
                          if buf[c] == 0x3a { colon = c; break }
                          c = c + 1
                      }
                      if colon >= 0 {
                          var vq: i64 = 0 - 1
                          var q: i64 = colon + 1
                          while q < end {
                              if buf[q] == 0x22 { vq = q; break }
                              q = q + 1
                          }
                          if vq >= 0 {
                              let vstart: i64 = vq + 1
                              var fe: i64 = 0 - 1
                              var e: i64 = vstart
                              while e < end {
                                  if buf[e] == 0x22 { fe = e; break }
                                  e = e + 1
                              }
                              if fe >= 0 {
                                  out_off[0] = vstart
                                  out_len[0] = fe - vstart
                                  return 1
                              }
                          }
                      }
                  }
              }
          }
      }
      i = i + 1
  }
  return 0
310}
311
312// ---- KAT: live directory -> newNonce URL -> GET nonce -> Replay-Nonce ----
313func main() -> i64 {
  let cdpath: *u8 = "/tmp/mozilla_certdata.txt\x00"
  let lr: i64 = nx_trust_store_load_from_certdata(cdpath, 300, NX_MAGIC_4194304)
  if lr <= 0 { sys_write(2, "trust load FAIL\n" as *u8, 16); return 1 }
  let store: *TrustStore = lr as *TrustStore
318
  let now: i64 = NX_MAGIC_1779284141
320
  // 1. GET directory
  let dir_url: *u8 = "https://acme-v02.api.letsencrypt.org/directory\x00"
  let buf: *u8 = sys_mmap(NX_MAGIC_65536)
  let tot: *i64 = sys_mmap(8) as *i64
  if nx_acme_req(dir_url, 46, 0, 0 as *u8, 0, 0 as *u8, 0, store, now, buf, NX_MAGIC_65536, tot) != NX_ACME_HTTP_OK {
      sys_write(2, "directory req FAIL\n" as *u8, 19); return 2
  }
  let r: *i64 = nx_http_resp_alloc()
  if nx_http_response_parse(buf, tot[0], r) != 0 { sys_write(2, "dir parse FAIL\n" as *u8, 15); return 3 }
  if r[1] != 200 { sys_write(2, "dir not 200\n" as *u8, 12); return 4 }
331
  // body region
  let body_off: i64 = r[6]
  let body_len: i64 = tot[0] - body_off
  let voff: *i64 = sys_mmap(8) as *i64
  let vlen: *i64 = sys_mmap(8) as *i64
  if nx_acme_json_str(buf, body_off, body_len, "newNonce" as *u8, 8, voff, vlen) != 1 {
      sys_write(2, "newNonce key not found\n" as *u8, 23); return 5
  }
  sys_write(1, "newNonce URL: " as *u8, 14); sys_write(1, buf + voff[0], vlen[0]); sys_write(1, "\n" as *u8, 1)
341
  // 2. GET newNonce, read Replay-Nonce header
  let nurl: *u8 = sys_mmap(256)
  var z: i64 = 0
  while z < vlen[0] { nurl[z] = buf[voff[0] + z]; z = z + 1 }
  nurl[vlen[0]] = 0 as u8
  let buf2: *u8 = sys_mmap(NX_MAGIC_16384)
  let tot2: *i64 = sys_mmap(8) as *i64
  if nx_acme_req(nurl, vlen[0], 0, 0 as *u8, 0, 0 as *u8, 0, store, now, buf2, NX_MAGIC_16384, tot2) != NX_ACME_HTTP_OK {
      sys_write(2, "nonce req FAIL\n" as *u8, 15); return 6
  }
  let r2: *i64 = nx_http_resp_alloc()
  if nx_http_response_parse(buf2, tot2[0], r2) != 0 { sys_write(2, "nonce parse FAIL\n" as *u8, 17); return 7 }
  let no: *i64 = sys_mmap(8) as *i64
  let nl: *i64 = sys_mmap(8) as *i64
  if nx_http_response_header(buf2, tot2[0], r2, "Replay-Nonce" as *u8, 12, no, nl) != 1 {
      sys_write(2, "Replay-Nonce header missing\n" as *u8, 28); return 8
  }
  sys_write(1, "Replay-Nonce: " as *u8, 14); sys_write(1, buf2 + no[0], nl[0]); sys_write(1, "\n" as *u8, 1)
  sys_write(1, "ACME HTTP layer KAT PASS (directory + nonce, live)\n" as *u8, 51)
  return 0
362}
nx_acme_http.nx source

`nx_acme_http.nx` source
