@scriptc/runtime 0.0.30 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "scriptc native runtime — C sources, compiled into every scriptc binary",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

package/src/scr_musl.c

@@ -2,7 +2,7 @@
  * this TU together with -DSCR_MUSL). musl deliberately provides no libc
  * identification macro, so the target-selected project macro is the guard.
  *
- * The x86_64 ucontext implementation below is derived from libucontext
+ * The x86_64 and AArch64 ucontext implementations below are derived from libucontext
  * commit 49e671dd52ff6791295d8161ad3b6da7dc5f6f9d:
  * https://github.com/kaniini/libucontext
  *
@@ -27,8 +27,8 @@
 #include <ucontext.h>
 #endif
 
-#if !defined(__x86_64__)
-#error "scriptc's musl runtime currently supports x86_64 only"
+#if !defined(__x86_64__) && !defined(__aarch64__)
+#error "scriptc's musl runtime currently supports x86_64 and AArch64 only"
 #endif
 
 /* The scriptc runtime uses arc4random_buf as its infallible CSPRNG contract.
@@ -57,9 +57,10 @@ void arc4random_buf(void *buf, size_t n) {
 
 /* musl exposes the POSIX ucontext types but intentionally omits these legacy
  * functions. scriptc's async/generator fibers need only user-space register
- * swaps; they never use a context to mutate the process signal mask. This is
- * libucontext's fast (non-POSIX-signal-mask) x86_64 implementation, emitted
- * under the standard symbol names that musl leaves unresolved. */
+ * swaps; they never use a context to mutate the process signal mask. These are
+ * libucontext's fast (non-POSIX-signal-mask) implementations, emitted under
+ * the standard symbol names that musl leaves unresolved. */
+#if defined(__x86_64__)
 _Static_assert(offsetof(ucontext_t, uc_mcontext.gregs) == 40,
                "unexpected musl x86_64 ucontext layout");
 _Static_assert(offsetof(ucontext_t, uc_mcontext.fpregs) == 224,
@@ -265,6 +266,169 @@ void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...) {
 #undef SCR_STR
 #undef SCR_STR_INNER
 
+#elif defined(__aarch64__)
+
+/* musl's AArch64 ucontext embeds the kernel sigcontext after a 128-byte
+ * signal mask. Keep the offsets pinned to the Zig 0.16 musl headers: the
+ * assembly below saves the ABI's callee-preserved GPR and SIMD state there. */
+_Static_assert(offsetof(ucontext_t, uc_mcontext.regs[0]) == 184,
+               "unexpected musl AArch64 register layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.sp) == 432,
+               "unexpected musl AArch64 stack-pointer layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.pc) == 440,
+               "unexpected musl AArch64 program-counter layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.pstate) == 448,
+               "unexpected musl AArch64 processor-state layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.__reserved) == 464,
+               "unexpected musl AArch64 SIMD-state layout");
+
+#define SCR_STR_INNER(x) #x
+#define SCR_STR(x) SCR_STR_INNER(x)
+#define SCR_A64_UC_REG(reg) (184 + ((reg) * 8))
+#define SCR_A64_UC_SP 432
+#define SCR_A64_UC_PC 440
+#define SCR_A64_UC_PSTATE 448
+#define SCR_A64_UC_FPSIMD 464
+
+__asm__(
+    ".text\n"
+    ".p2align 2\n"
+    ".global getcontext\n"
+    "getcontext:\n"
+    "  str xzr, [x0, #" SCR_STR(SCR_A64_UC_REG(0)) "]\n"
+    "  stp x2, x3, [x0, #" SCR_STR(SCR_A64_UC_REG(2)) "]\n"
+    "  str x30, [x0, #" SCR_STR(SCR_A64_UC_PC) "]\n"
+    "  mov x2, sp\n"
+    "  str x2, [x0, #" SCR_STR(SCR_A64_UC_SP) "]\n"
+    "  str xzr, [x0, #" SCR_STR(SCR_A64_UC_PSTATE) "]\n"
+    "  add x2, x0, #" SCR_STR(SCR_A64_UC_FPSIMD) "\n"
+    "  stp q8, q9, [x2, #144]\n"
+    "  stp q10, q11, [x2, #176]\n"
+    "  stp q12, q13, [x2, #208]\n"
+    "  stp q14, q15, [x2, #240]\n"
+    "  mov x2, x0\n"
+    "  mov x0, #0\n"
+    "  stp x0, x1, [x2, #" SCR_STR(SCR_A64_UC_REG(0)) "]\n"
+    "  stp x4, x5, [x2, #" SCR_STR(SCR_A64_UC_REG(4)) "]\n"
+    "  stp x6, x7, [x2, #" SCR_STR(SCR_A64_UC_REG(6)) "]\n"
+    "  stp x8, x9, [x2, #" SCR_STR(SCR_A64_UC_REG(8)) "]\n"
+    "  stp x10, x11, [x2, #" SCR_STR(SCR_A64_UC_REG(10)) "]\n"
+    "  stp x12, x13, [x2, #" SCR_STR(SCR_A64_UC_REG(12)) "]\n"
+    "  stp x14, x15, [x2, #" SCR_STR(SCR_A64_UC_REG(14)) "]\n"
+    "  stp x16, x17, [x2, #" SCR_STR(SCR_A64_UC_REG(16)) "]\n"
+    "  stp x18, x19, [x2, #" SCR_STR(SCR_A64_UC_REG(18)) "]\n"
+    "  stp x20, x21, [x2, #" SCR_STR(SCR_A64_UC_REG(20)) "]\n"
+    "  stp x22, x23, [x2, #" SCR_STR(SCR_A64_UC_REG(22)) "]\n"
+    "  stp x24, x25, [x2, #" SCR_STR(SCR_A64_UC_REG(24)) "]\n"
+    "  stp x26, x27, [x2, #" SCR_STR(SCR_A64_UC_REG(26)) "]\n"
+    "  stp x28, x29, [x2, #" SCR_STR(SCR_A64_UC_REG(28)) "]\n"
+    "  str x30, [x2, #" SCR_STR(SCR_A64_UC_REG(30)) "]\n"
+    "  ret\n"
+
+    ".p2align 2\n"
+    ".global setcontext\n"
+    "setcontext:\n"
+    "  ldp x18, x19, [x0, #" SCR_STR(SCR_A64_UC_REG(18)) "]\n"
+    "  ldp x20, x21, [x0, #" SCR_STR(SCR_A64_UC_REG(20)) "]\n"
+    "  ldp x22, x23, [x0, #" SCR_STR(SCR_A64_UC_REG(22)) "]\n"
+    "  ldp x24, x25, [x0, #" SCR_STR(SCR_A64_UC_REG(24)) "]\n"
+    "  ldp x26, x27, [x0, #" SCR_STR(SCR_A64_UC_REG(26)) "]\n"
+    "  ldp x28, x29, [x0, #" SCR_STR(SCR_A64_UC_REG(28)) "]\n"
+    "  ldr x30, [x0, #" SCR_STR(SCR_A64_UC_REG(30)) "]\n"
+    "  ldr x2, [x0, #" SCR_STR(SCR_A64_UC_SP) "]\n"
+    "  mov sp, x2\n"
+    "  add x2, x0, #" SCR_STR(SCR_A64_UC_FPSIMD) "\n"
+    "  ldp q8, q9, [x2, #144]\n"
+    "  ldp q10, q11, [x2, #176]\n"
+    "  ldp q12, q13, [x2, #208]\n"
+    "  ldp q14, q15, [x2, #240]\n"
+    "  ldr x16, [x0, #" SCR_STR(SCR_A64_UC_PC) "]\n"
+    "  ldp x2, x3, [x0, #" SCR_STR(SCR_A64_UC_REG(2)) "]\n"
+    "  ldp x4, x5, [x0, #" SCR_STR(SCR_A64_UC_REG(4)) "]\n"
+    "  ldp x6, x7, [x0, #" SCR_STR(SCR_A64_UC_REG(6)) "]\n"
+    "  ldp x0, x1, [x0, #" SCR_STR(SCR_A64_UC_REG(0)) "]\n"
+    "  br x16\n"
+
+    ".p2align 2\n"
+    ".global swapcontext\n"
+    "swapcontext:\n"
+    "  str xzr, [x0, #" SCR_STR(SCR_A64_UC_REG(0)) "]\n"
+    "  stp x2, x3, [x0, #" SCR_STR(SCR_A64_UC_REG(2)) "]\n"
+    "  stp x4, x5, [x0, #" SCR_STR(SCR_A64_UC_REG(4)) "]\n"
+    "  stp x6, x7, [x0, #" SCR_STR(SCR_A64_UC_REG(6)) "]\n"
+    "  stp x8, x9, [x0, #" SCR_STR(SCR_A64_UC_REG(8)) "]\n"
+    "  stp x10, x11, [x0, #" SCR_STR(SCR_A64_UC_REG(10)) "]\n"
+    "  stp x12, x13, [x0, #" SCR_STR(SCR_A64_UC_REG(12)) "]\n"
+    "  stp x14, x15, [x0, #" SCR_STR(SCR_A64_UC_REG(14)) "]\n"
+    "  stp x16, x17, [x0, #" SCR_STR(SCR_A64_UC_REG(16)) "]\n"
+    "  stp x18, x19, [x0, #" SCR_STR(SCR_A64_UC_REG(18)) "]\n"
+    "  stp x20, x21, [x0, #" SCR_STR(SCR_A64_UC_REG(20)) "]\n"
+    "  stp x22, x23, [x0, #" SCR_STR(SCR_A64_UC_REG(22)) "]\n"
+    "  stp x24, x25, [x0, #" SCR_STR(SCR_A64_UC_REG(24)) "]\n"
+    "  stp x26, x27, [x0, #" SCR_STR(SCR_A64_UC_REG(26)) "]\n"
+    "  stp x28, x29, [x0, #" SCR_STR(SCR_A64_UC_REG(28)) "]\n"
+    "  str x30, [x0, #" SCR_STR(SCR_A64_UC_REG(30)) "]\n"
+    "  str x30, [x0, #" SCR_STR(SCR_A64_UC_PC) "]\n"
+    "  mov x2, sp\n"
+    "  str x2, [x0, #" SCR_STR(SCR_A64_UC_SP) "]\n"
+    "  str xzr, [x0, #" SCR_STR(SCR_A64_UC_PSTATE) "]\n"
+    "  add x2, x0, #" SCR_STR(SCR_A64_UC_FPSIMD) "\n"
+    "  stp q8, q9, [x2, #144]\n"
+    "  stp q10, q11, [x2, #176]\n"
+    "  stp q12, q13, [x2, #208]\n"
+    "  stp q14, q15, [x2, #240]\n"
+    "  mov x0, x1\n"
+    "  b setcontext\n"
+
+    ".p2align 2\n"
+    ".hidden scr_musl_context_trampoline\n"
+    "scr_musl_context_trampoline:\n"
+    "  mov x0, x19\n"
+    "  cbz x0, 1f\n"
+    "  bl setcontext\n"
+    "  brk #0\n"
+    "1:\n"
+    "  mov w0, #0\n"
+    "  bl exit\n"
+    "  brk #0\n");
+
+extern void scr_musl_context_trampoline(void);
+
+void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...) {
+  greg_t *sp;
+  va_list va;
+  int i;
+
+  sp = (greg_t *)((uintptr_t)ucp->uc_stack.ss_sp + ucp->uc_stack.ss_size);
+  sp -= argc < 8 ? 0 : argc - 8;
+  sp = (greg_t *)((uintptr_t)sp & ~(uintptr_t)15);
+
+  ucp->uc_mcontext.sp = (greg_t)(uintptr_t)sp;
+  ucp->uc_mcontext.pc = (greg_t)(uintptr_t)func;
+  ucp->uc_mcontext.regs[19] = (greg_t)(uintptr_t)ucp->uc_link;
+  ucp->uc_mcontext.regs[30] =
+      (greg_t)(uintptr_t)&scr_musl_context_trampoline;
+
+  va_start(va, argc);
+  for (i = 0; i < argc && i < 8; i++) {
+    ucp->uc_mcontext.regs[i] = va_arg(va, greg_t);
+  }
+  for (; i < argc; i++) {
+    *sp++ = va_arg(va, greg_t);
+  }
+  va_end(va);
+}
+
+#undef SCR_A64_UC_FPSIMD
+#undef SCR_A64_UC_PSTATE
+#undef SCR_A64_UC_PC
+#undef SCR_A64_UC_SP
+#undef SCR_A64_UC_REG
+#undef SCR_STR
+#undef SCR_STR_INNER
+
+#endif /* architecture */
+
 #endif /* !SCR_LIB */
 
 #else /* !SCR_MUSL */

package/src/scr_runtime.h

@@ -5493,18 +5493,25 @@ long scr_secure_ctx_live_count(void);
 #endif
 
 /* ── node:tls, the CA-store introspection slice (scr_tls_ca.c — its own
- * unit and link gate; plain PEM-block bookkeeping, NO mbedTLS, so a
- * getCACertificates-only binary never builds the archive; cc.ts also
- * compiles it whenever scr_tls.c does). The HOST bundle (the
- * /etc/ssl/cert.pem probe order scr_tls.c documents) stands in for both
- * Node's compiled-in Mozilla roots ('bundled', rootCertificates) and the
- * platform store ('system') — the established SEMANTICS divergence,
- * extended to introspection; 'extra' uses the NODE_EXTRA_CA_CERTS file
- * captured before user code runs. Arrays are cached per type (+1 retained
- * answers each call — Node's own caching, and the identity the suite pins
- * with strictEqual). */
+ * unit and link gate; NO mbedTLS, so a getCACertificates-only binary never
+ * builds the archive; cc.ts also compiles it whenever scr_tls.c does). The
+ * HOST roots (Windows' system certificate stores, the established bundle probe on
+ * POSIX) stand in for both Node's compiled-in Mozilla roots ('bundled',
+ * rootCertificates) and the platform store ('system') — the established
+ * SEMANTICS divergence, extended to introspection; 'extra' uses the
+ * NODE_EXTRA_CA_CERTS file captured before user code runs. Arrays are cached
+ * per type (+1 retained answers each call — Node's own caching, and the
+ * identity the suite pins with strictEqual). */
 void scr_tls_ca_install(void); /* snapshots NODE_EXTRA_CA_CERTS + file bytes */
 bool scr_tls_ca_extra_pem(const char **pem, size_t *len); /* borrowed launch snapshot */
+#ifdef _WIN32
+/* Enumerates Windows' trusted ROOT, intermediate CA, and TrustedPeople store
+ * locations, yielding only certificates whose effective Windows EKU policy
+ * permits TLS server authentication. DER is borrowed for the call. */
+typedef void (*ScrTlsCaWindowsCertFn)(void *ctx, const unsigned char *der, size_t len);
+bool scr_tls_ca_windows_cert_server_auth(const void *cert_context);
+void scr_tls_ca_windows_certs(ScrTlsCaWindowsCertFn fn, void *ctx);
+#endif
 ScrArr *scr_tls_ca_get(ScrStr *type); /* +1; throws ERR_INVALID_ARG_VALUE on unknown types */
 ScrArr *scr_tls_ca_root(void);        /* +1; === getCACertificates("bundled") */
 /* Replaces the 'default' set: entries filter to their PEM certificate

package/src/scr_tls.c

@@ -56,7 +56,7 @@
  * head buffers in the socket's write buffer until the handshake
  * establishes (the mid-connect buffering path, reused verbatim).
  * rejectUnauthorized:false maps to VERIFY_NONE; `ca` replaces the trust
- * anchors; with neither, /etc/ssl/cert.pem stands in for Node's bundled
+ * anchors; with neither, the host trust store stands in for Node's bundled
  * Mozilla roots (SEMANTICS.md documents the divergence). Verify
  * failures surface as Node-shaped 'error' messages on the request
  * ("self-signed certificate", "self-signed certificate in certificate
@@ -336,15 +336,15 @@ typedef struct ScrTlsCli {
   bool verify_recorded;
 } ScrTlsCli;
 
-/* The default trust anchors when no `ca` option is given: the system
- * bundle, standing in for Node's compiled-in Mozilla roots, plus
- * NODE_EXTRA_CA_CERTS. The system bundle is probed once across the distro
- * spellings — /etc/ssl/cert.pem first (macOS ships it; Alpine links it),
- * then Debian/Ubuntu's ca-certificates.crt, Fedora/RHEL's ca-bundle.crt,
- * and openSUSE's ca-bundle.pem. On macOS only the first path exists, so
- * the probe order changes nothing there. A host with none leaves only the
- * optional extra chain. Windows is that host by construction (no PEM
- * bundle ships; the OS store is cert-database-shaped). */
+/* The default trust anchors when no `ca` option is given: the host trust
+ * store, standing in for Node's compiled-in Mozilla roots, plus
+ * NODE_EXTRA_CA_CERTS. Windows certificates live as DER entries across the
+ * machine, enterprise, current-user, and policy ROOT/CA/TrustedPeople store
+ * locations; mbedTLS copies each successfully parsed entry into its own chain.
+ * POSIX hosts probe the established bundle spellings — /etc/ssl/cert.pem
+ * first (macOS ships it; Alpine links it), then Debian/Ubuntu's
+ * ca-certificates.crt, Fedora/RHEL's ca-bundle.crt, and openSUSE's
+ * ca-bundle.pem. */
 static mbedtls_x509_crt scr_tls_system_roots;
 static bool scr_tls_system_roots_loaded = false;
 
@@ -356,6 +356,12 @@ static bool scr_tls_system_roots_loaded = false;
 static mbedtls_x509_crt scr_tls_override_roots;
 static uint64_t scr_tls_override_parsed_gen = 0;
 
+#ifdef _WIN32
+static void scr_tls_add_windows_ca(void *ctx, const unsigned char *der, size_t len) {
+  (void)mbedtls_x509_crt_parse_der((mbedtls_x509_crt *)ctx, der, len);
+}
+#endif
+
 static mbedtls_x509_crt *scr_tls_system_ca(void) {
   const char *pem = NULL;
   size_t pem_len = 0;
@@ -375,6 +381,12 @@ static mbedtls_x509_crt *scr_tls_system_ca(void) {
   if (!scr_tls_system_roots_loaded) {
     scr_tls_system_roots_loaded = true;
     mbedtls_x509_crt_init(&scr_tls_system_roots);
+#ifdef _WIN32
+    /* The shared enumerator applies Windows' effective server-auth EKU
+     * policy before yielding DER. mbedTLS copies every successfully parsed
+     * entry, so the store contexts may die immediately after each callback. */
+    scr_tls_ca_windows_certs(scr_tls_add_windows_ca, &scr_tls_system_roots);
+#else
     static const char *const bundles[] = {
         "/etc/ssl/cert.pem",                  /* macOS, Alpine */
         "/etc/ssl/certs/ca-certificates.crt", /* Debian/Ubuntu */
@@ -384,6 +396,7 @@ static mbedtls_x509_crt *scr_tls_system_ca(void) {
     for (size_t i = 0; i < sizeof bundles / sizeof bundles[0]; i++) {
       if (mbedtls_x509_crt_parse_file(&scr_tls_system_roots, bundles[i]) == 0) break;
     }
+#endif
     const char *extra = NULL;
     size_t extra_len = 0;
     if (scr_tls_ca_extra_pem(&extra, &extra_len) && extra_len > 0) {

package/src/scr_tls_ca.c

@@ -2,28 +2,33 @@
  * rootCertificates, and setDefaultCACertificates (scr_runtime.h has the
  * contracts). Its own link gate ("tlsca." libCalls), deliberately free
  * of mbedTLS: everything here is PEM-BLOCK bookkeeping over the host
- * bundle, so a program that only inspects the CA store keeps the lean
- * link line. scr_tls.c (when it links — cc.ts compiles this unit
- * alongside it) consults scr_tls_ca_default_override for its client
- * trust anchors, which is what makes setDefaultCACertificates LIVE
- * semantics: the next https/tls dial verifies against the replaced set.
+ * roots (plus crypt32 store access on Windows), so a program that only
+ * inspects the CA store never builds the TLS archive. scr_tls.c (when it
+ * links — cc.ts compiles this unit alongside it) consults
+ * scr_tls_ca_default_override for its client trust anchors, which is what
+ * makes setDefaultCACertificates LIVE semantics: the next https/tls dial
+ * verifies against the replaced set.
  *
  * Divergences, documented: the host bundle stands in for Node's
  * compiled-in Mozilla roots ('bundled' and rootCertificates) AND for the
- * platform store ('system') — the same /etc/ssl/cert.pem stance
- * scr_tls.c's anchors established; and set-time validation is PEM-BLOCK
- * shaped (a well-formed block with corrupt DER inside is kept here where
- * Node's X509 parse would drop it — such a cert then fails verification
- * instead, the same observable outcome one step later). Deduplication is
- * byte-exact over the extracted block where Node compares parsed X509
- * identities; re-encoded duplicates of one certificate stay distinct
- * entries, which no equality the tests observe can distinguish without a
- * parser. */
+ * platform store ('system') — Windows' system certificate stores and the POSIX
+ * bundle probe are the same sources scr_tls.c's anchors use; and set-time
+ * validation is PEM-BLOCK shaped (a well-formed block with corrupt DER
+ * inside is kept here where Node's X509 parse would drop it — such a cert
+ * then fails verification instead, the same observable outcome one step
+ * later). Deduplication is byte-exact over the extracted block where Node
+ * compares parsed X509 identities; re-encoded duplicates of one certificate
+ * stay distinct entries, which no equality the tests observe can distinguish
+ * without a parser. */
 #include "scr_runtime.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#include <wincrypt.h>
+#endif
 
 /* The per-type caches: +1 held here for the process lifetime (an atexit
  * teardown releases them so the RC audit stays clean). 'default' also
@@ -154,9 +159,121 @@ bool scr_tls_ca_extra_pem(const char **pem, size_t *len) {
   return true;
 }
 
-/* The host bundle, probed in scr_tls.c's documented order. */
+#ifdef _WIN32
+/* Windows can restrict a certificate's purposes in a store property that is
+ * not part of its DER. CertGetEnhancedKeyUsage with flags 0 intersects that
+ * property with the encoded EKU extension. An empty result means either all
+ * purposes (CRYPT_E_NOT_FOUND) or no purposes (ERROR_SUCCESS); every other
+ * API failure is fail-closed too. */
+bool scr_tls_ca_windows_cert_server_auth(const void *cert_context) {
+  PCCERT_CONTEXT cert = (PCCERT_CONTEXT)cert_context;
+  DWORD usage_len = 0;
+  if (!CertGetEnhancedKeyUsage(cert, 0, NULL, &usage_len) || usage_len == 0) {
+    return false;
+  }
+  CERT_ENHKEY_USAGE *usage = malloc((size_t)usage_len);
+  if (usage == NULL) scr_ca_oom();
+  if (!CertGetEnhancedKeyUsage(cert, 0, usage, &usage_len)) {
+    free(usage);
+    return false;
+  }
+  DWORD usage_error = GetLastError();
+  bool allowed = usage->cUsageIdentifier == 0 &&
+      usage_error == CRYPT_E_NOT_FOUND;
+  for (DWORD i = 0; !allowed && usage->rgpszUsageIdentifier != NULL &&
+       i < usage->cUsageIdentifier; i++) {
+    const char *oid = usage->rgpszUsageIdentifier[i];
+    allowed = oid != NULL &&
+        (strcmp(oid, szOID_PKIX_KP_SERVER_AUTH) == 0 ||
+         strcmp(oid, szOID_ANY_ENHANCED_KEY_USAGE) == 0);
+  }
+  free(usage);
+  return allowed;
+}
+
+static void scr_tls_ca_windows_certs_at(
+    DWORD location, const char *store_name, HCERTSTORE seen,
+    ScrTlsCaWindowsCertFn fn, void *ctx) {
+  HCERTSTORE store = CertOpenStore(
+      CERT_STORE_PROV_SYSTEM_A, 0, 0,
+      location | CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG,
+      store_name);
+  if (store == NULL) return;
+  PCCERT_CONTEXT cert = NULL;
+  /* CertEnumCertificatesInStore frees the previous context on every call,
+   * including the final NULL result. Each callback must copy DER it keeps. */
+  while ((cert = CertEnumCertificatesInStore(store, cert)) != NULL) {
+    /* The logical stores overlap (notably CurrentUser inherits machine
+     * roots). CERT_STORE_ADD_NEW turns the memory store into a process-local
+     * identity set: only the first allowed context reaches the consumer. */
+    if (scr_tls_ca_windows_cert_server_auth(cert) &&
+        CertAddCertificateContextToStore(
+            seen, cert, CERT_STORE_ADD_NEW, NULL)) {
+      fn(ctx, cert->pbCertEncoded, (size_t)cert->cbCertEncoded);
+    }
+  }
+  (void)CertCloseStore(store, 0);
+}
+
+void scr_tls_ca_windows_certs(ScrTlsCaWindowsCertFn fn, void *ctx) {
+  /* Match Node's Windows system-certificate sources: roots and intermediate
+   * CAs from all five applicable locations, plus explicitly trusted server
+   * certificates from the three local-machine TrustedPeople locations.
+   * A memory store deduplicates their overlapping contents. */
+  typedef struct ScrTlsCaWindowsStore {
+    DWORD location;
+    const char *name;
+  } ScrTlsCaWindowsStore;
+  static const ScrTlsCaWindowsStore stores[] = {
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE, "ROOT"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY, "ROOT"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, "ROOT"},
+      {CERT_SYSTEM_STORE_CURRENT_USER, "ROOT"},
+      {CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY, "ROOT"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE, "CA"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY, "CA"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, "CA"},
+      {CERT_SYSTEM_STORE_CURRENT_USER, "CA"},
+      {CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY, "CA"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE, "TrustedPeople"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY, "TrustedPeople"},
+      {CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, "TrustedPeople"},
+  };
+  HCERTSTORE seen = CertOpenStore(
+      CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
+  if (seen == NULL) return;
+  for (size_t i = 0; i < sizeof stores / sizeof stores[0]; i++) {
+    scr_tls_ca_windows_certs_at(
+        stores[i].location, stores[i].name, seen, fn, ctx);
+  }
+  (void)CertCloseStore(seen, 0);
+}
+
+static void scr_ca_push_windows_cert(void *ctx, const unsigned char *der, size_t len) {
+  if (len > UINT32_MAX) return;
+  DWORD pem_cap = 0;
+  DWORD flags = CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR;
+  if (!CryptBinaryToStringA(der, (DWORD)len, flags, NULL, &pem_cap) ||
+      pem_cap == 0) {
+    return;
+  }
+  char *pem = malloc((size_t)pem_cap);
+  if (pem == NULL) scr_ca_oom();
+  DWORD pem_len = pem_cap;
+  if (CryptBinaryToStringA(der, (DWORD)len, flags, pem, &pem_len)) {
+    scr_arr_push_ref((ScrArr *)ctx, scr_str_new(pem, (size_t)pem_len));
+  }
+  free(pem);
+}
+#endif
+
+/* The host roots, from the Windows logical store or the POSIX bundle probe
+ * shared with scr_tls.c. */
 static ScrArr *scr_ca_load_host_bundle(void) {
   ScrArr *arr = scr_arr_new(SCR_ELEM_STR, 128);
+#ifdef _WIN32
+  scr_tls_ca_windows_certs(scr_ca_push_windows_cert, arr);
+#else
   static const char *const bundles[] = {
       "/etc/ssl/cert.pem",                  /* macOS, Alpine */
       "/etc/ssl/certs/ca-certificates.crt", /* Debian/Ubuntu */
@@ -171,6 +288,7 @@ static ScrArr *scr_ca_load_host_bundle(void) {
     free(text);
     break; /* first bundle wins, like the anchor probe */
   }
+#endif
   return arr;
 }
 

package/vendor/README.md

@@ -6,7 +6,7 @@
 - Commit: 49e671dd52ff6791295d8161ad3b6da7dc5f6f9d
 - License: ISC (copyright and permission notice reproduced in `src/scr_musl.c`)
 
-The x86_64 register-save/restore and `makecontext` logic is adapted into `src/scr_musl.c`, rather than carried as a separate library, to supply the legacy `ucontext` functions that musl declares but does not implement. It is compiled only for the explicit `x86_64-linux-musl` target and uses musl's public `ucontext_t` layout. The signal-mask compatibility wrapper is deliberately not included: scriptc fibers perform user-space register swaps and do not change a per-fiber signal mask.
+The x86_64 and AArch64 register-save/restore and `makecontext` logic is adapted into `src/scr_musl.c`, rather than carried as a separate library, to supply the legacy `ucontext` functions that musl declares but does not implement. It is compiled for the explicit `x86_64-linux-musl` and `aarch64-linux-musl` targets and uses musl's public `ucontext_t` layouts. The signal-mask compatibility wrapper is deliberately not included: scriptc fibers perform user-space register swaps and do not change a per-fiber signal mask.
 
 ## ryu/