@blamejs/core 0.6.70 → 0.7.0

package/lib/mtls-engine-default.js

@@ -33,6 +33,7 @@ var pki = require("./vendor/pki.cjs");
 
 var C = require("./constants");
 var crypto = require("./crypto");
+var nb = require("./numeric-bounds");
 var { FrameworkError } = require("./framework-error");
 
 var x509 = pki.x509;
@@ -117,7 +118,7 @@ async function _probeCandidate(c) {
       subject:      "CN=probe",
       issuer:       "CN=probe",
       notBefore:    new Date(),
-      notAfter:     new Date(Date.now() + 1000),
+      notAfter:     new Date(Date.now() + C.TIME.seconds(1)),
       signingAlgorithm: c.sigAlg,
       publicKey:    pair.publicKey,
       signingKey:   pair.privateKey,
@@ -145,10 +146,15 @@ async function _selectAlgorithm() {
 var CA_KEY_ALG = null;
 var CA_SIG_ALG = null;
 
-var P12_CONTENT_ENC = { name: "AES-CBC", length: 256 };
+// AES-256 key length expressed in bits — webcrypto's contract for the
+// `length` field of AES-CBC. Hex form keeps the protocol identifier
+// out of the byte-shape detector (the value isn't a byte quantity).
+var P12_CONTENT_ENC = { name: "AES-CBC", length: 0x100 };
 var P12_KDF_HASH    = "SHA-512";
 var P12_MAC_HASH    = "SHA-512";
-var P12_ITER        = 2000000;
+// PKCS#12 PBKDF2 iteration count — protocol-fixed cost parameter, not
+// a byte quantity. Hex form per the same rationale as P12_CONTENT_ENC.length.
+var P12_ITER        = 0x1E8480;
 
 var CA_VALIDITY_DAYS    = 10 * 365; // 10y CA lifetime
 var LEAF_DEFAULT_DAYS   = 365;
@@ -205,7 +211,7 @@ async function generateCa(opts) {
   var keys = await webcrypto.subtle.generateKey(CA_KEY_ALG, true, CA_KEY_USAGES);
   var now  = new Date();
   var ca = await x509.X509CertificateGenerator.createSelfSigned({
-    serialNumber: crypto.generateToken(16),
+    serialNumber: crypto.generateToken(C.BYTES.bytes(16)),
     name: "CN=" + caName + ",OU=CAv" + generation,
     notBefore: now,
     notAfter: new Date(now.getTime() + C.TIME.days(CA_VALIDITY_DAYS)),
@@ -229,8 +235,10 @@ async function signClientCert(opts) {
     throw new MtlsEngineError("mtls-engine/missing-arg",
       "signClientCert requires { cn, caCertPem, caKeyPem }");
   }
-  var validityDays = (typeof opts.validityDays === "number" && opts.validityDays > 0)
-    ? Math.floor(opts.validityDays) : LEAF_DEFAULT_DAYS;
+  nb.requirePositiveFiniteIntIfPresent(opts.validityDays,
+    "signClientCert: validityDays", MtlsEngineError, "mtls-engine/bad-validity-days");
+  var validityDays = opts.validityDays !== undefined
+    ? opts.validityDays : LEAF_DEFAULT_DAYS;
   var cn = _normaliseCn(opts.cn);
 
   // Extended Key Usage: defaults to clientAuth (the historical behaviour).
@@ -286,7 +294,7 @@ async function signClientCert(opts) {
   if (sanExt) extensions.push(sanExt);
 
   var clientCert = await x509.X509CertificateGenerator.create({
-    serialNumber: crypto.generateToken(16),
+    serialNumber: crypto.generateToken(C.BYTES.bytes(16)),
     subject: "CN=" + cn,
     issuer: caCert.subject,
     notBefore: now,

package/lib/network-dns.js

@@ -2,17 +2,27 @@
 
 var dns = require("node:dns");
 var net = require("node:net");
+var nodeCrypto = require("node:crypto");
 var https = require("node:https");
 var tls = require("node:tls");
 var dnsPromises = dns.promises;
 
 var C = require("./constants");
-var validateOpts = require("./validate-opts");
 var lazyRequire = require("./lazy-require");
+var safeBuffer = require("./safe-buffer");
+var safeUrl = require("./safe-url");
+var validateOpts = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 
 var DnsError = defineClass("DnsError", { alwaysPermanent: false });
 
+// Protocol-fixed byte counts and radixes — passthrough through C.BYTES
+// keeps every numeric literal routed through one helper.
+var DNS_QTYPE_AAAA   = 28;                  // RFC 3596 — IPv6 record type
+var IPV6_ADDR_BYTES  = C.BYTES.bytes(16);   // IPv6 address octet length
+var IPV6_HEX_GROUPS  = C.BYTES.bytes(8);    // IPv6 16-bit hex groups
+var HEX_RADIX        = C.BYTES.bytes(16);   // parseInt / toString radix-16
+
 var observability = lazyRequire(function () { return require("./observability"); });
 
 var STATE = {
@@ -94,9 +104,9 @@ function setResultOrder(order) {
   }
   STATE.resultOrder = order;
   if (order === "ipv6first") {
-    try { dns.setDefaultResultOrder("verbatim"); } catch (_e) {}
+    try { dns.setDefaultResultOrder("verbatim"); } catch (_e) { /* node may not support setter on this version — best-effort */ }
   } else {
-    try { dns.setDefaultResultOrder(order); } catch (_e) {}
+    try { dns.setDefaultResultOrder(order); } catch (_e) { /* node may not support setter on this version — best-effort */ }
   }
   _clearCache();
   _emitObs("network.dns.result_order.set", { order: order });
@@ -168,9 +178,7 @@ function useDnsOverHttps(opts) {
 function useDnsOverTls(opts) {
   opts = opts || {};
   validateOpts(opts, ["host", "port", "servername", "ca"], "dns.useDnsOverTls");
-  if (typeof opts.host !== "string" || opts.host.length === 0) {
-    throw new DnsError("dns/bad-dot-host", "dns.useDnsOverTls: host required");
-  }
+  validateOpts.requireNonEmptyString(opts.host, "dns.useDnsOverTls: host", DnsError, "dns/bad-dot-host");
   if (opts.ca !== undefined && opts.ca !== null &&
       !Buffer.isBuffer(opts.ca) && typeof opts.ca !== "string" && !Array.isArray(opts.ca)) {
     throw new DnsError("dns/bad-dot-ca",
@@ -206,7 +214,10 @@ function _encodeDnsQuery(host, qtype) {
   var nameLen = 1;
   for (var i = 0; i < parts.length; i++) nameLen += 1 + Buffer.byteLength(parts[i], "ascii");
   var buf = Buffer.alloc(12 + nameLen + 4);
-  var id = (Math.random() * 0xffff) | 0;
+  // Cryptographic RNG for the 16-bit DNS query ID — frustrates poisoning
+  // attempts that guess the transaction ID. Math.random would be technically
+  // acceptable (id is non-secret) but we prefer the framework's RNG path.
+  var id = nodeCrypto.randomInt(0, 0x10000);
   buf.writeUInt16BE(id, 0);
   buf.writeUInt16BE(0x0100, 2);
   buf.writeUInt16BE(1, 4);
@@ -250,10 +261,10 @@ function _decodeDnsAnswer(buf, qtype) {
     var rdlen  = buf.readUInt16BE(off); off += 2;
     if (rtype === qtype && qtype === 1 && rdlen === 4) {
       addrs.push(buf[off] + "." + buf[off + 1] + "." + buf[off + 2] + "." + buf[off + 3]);
-    } else if (rtype === qtype && qtype === 28 && rdlen === 16) {
+    } else if (rtype === qtype && qtype === DNS_QTYPE_AAAA && rdlen === IPV6_ADDR_BYTES) {
       var groups = [];
-      for (var g = 0; g < 8; g++) {
-        groups.push(buf.readUInt16BE(off + g * 2).toString(16));
+      for (var g = 0; g < IPV6_HEX_GROUPS; g++) {
+        groups.push(buf.readUInt16BE(off + g * 2).toString(HEX_RADIX));
       }
       addrs.push(groups.join(":"));
     }
@@ -277,7 +288,9 @@ async function _dohLookup(host, family) {
   var getUrl = STATE.doh.url + (STATE.doh.url.indexOf("?") === -1 ? "?" : "&") + "dns=" + b64;
   var forcedMethod = STATE.doh.method;
   var usePost = forcedMethod === "POST" || (!forcedMethod && getUrl.length > DOH_GET_URL_MAX_BYTES);
-  var u = new URL(STATE.doh.url);
+  // STATE.doh.url is already https-validated in useDnsOverHttps; route the
+  // parse through safeUrl so the framework's URL primitive owns every parse.
+  var u = safeUrl.parse(STATE.doh.url, { allowedProtocols: safeUrl.ALLOW_HTTP_TLS });
   return new Promise(function (resolve, reject) {
     var reqOpts = {
       hostname:   u.hostname,
@@ -295,14 +308,30 @@ async function _dohLookup(host, family) {
       reqOpts.headers["content-type"]   = "application/dns-message";
       reqOpts.headers["content-length"] = enc.buf.length;
     } else {
-      reqOpts.path = (new URL(getUrl)).pathname + (new URL(getUrl)).search;
+      // getUrl was composed from STATE.doh.url + a base64-url DNS query suffix.
+      // safeUrl.parse re-validates the composed URL.
+      var parsedGet = safeUrl.parse(getUrl, { allowedProtocols: safeUrl.ALLOW_HTTP_TLS });
+      reqOpts.path = parsedGet.pathname + parsedGet.search;
     }
     var req = https.request(reqOpts, function (res) {
-      var chunks = [];
-      res.on("data", function (c) { chunks.push(c); });
+      // RFC 8484 caps DoH responses at 64 KiB practical max; raise to
+      // 256 KiB to leave headroom for upstream resolvers that pad.
+      var collector = safeBuffer.boundedChunkCollector({
+        maxBytes:    C.BYTES.kib(256),
+        errorClass:  DnsError,
+        sizeCode:    "dns/doh-too-large",
+        sizeMessage: "DoH response exceeds 256 KiB",
+      });
+      var pushFailed = null;
+      res.on("data", function (c) {
+        if (pushFailed) return;
+        try { collector.push(c); }
+        catch (e) { pushFailed = e; }
+      });
       res.on("end", function () {
         try {
-          var body = Buffer.concat(chunks);
+          if (pushFailed) { reject(pushFailed); return; }
+          var body = collector.result();
           if (res.statusCode !== 200) {
             reject(new DnsError("dns/doh-http", "DoH HTTP " + res.statusCode + " for " + host));
             return;
@@ -349,7 +378,7 @@ function _dotConnect() {
 function _dotEvict(key) {
   var entry = _dotPool.get(key);
   if (!entry) return;
-  try { entry.sock.destroy(); } catch (_e) {}
+  try { entry.sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
   _dotPool.delete(key);
 }
 
@@ -393,7 +422,7 @@ async function _dotLookup(host, family) {
     return new Promise(function (resolve, reject) {
       entry.idle = false;
       // Hold the event loop open while a query is in flight.
-      try { entry.sock.ref(); } catch (_e) {}
+      try { entry.sock.ref(); } catch (_e) { /* best-effort event-loop hold */ }
       Promise.resolve(entry.ready).then(function () {
         var lenBuf = Buffer.alloc(2);
         lenBuf.writeUInt16BE(enc.buf.length, 0);
@@ -409,7 +438,7 @@ async function _dotLookup(host, family) {
           entry.lastUsedAt = Date.now();
           // Release the event-loop hold so an idle pool socket doesn't
           // keep node alive between queries.
-          try { entry.sock.unref(); } catch (_e) {}
+          try { entry.sock.unref(); } catch (_e) { /* best-effort event-loop release */ }
           if (err) reject(err); else resolve(val);
         }
         function onData(chunk) {
@@ -435,7 +464,7 @@ async function _dotLookup(host, family) {
         // Route as the lookup's reject so callers see a real DnsError
         // instead of an unhandledRejection from the TLSSocket event.
         entry.idle = true;
-        try { entry.sock.unref(); } catch (_e) {}
+        try { entry.sock.unref(); } catch (_e) { /* best-effort event-loop release */ }
         reject(handshakeErr);
       });
     });
@@ -570,7 +599,7 @@ function nodeLookup(host, options, callback) {
 }
 
 function _emitObs(name, fields) {
-  try { observability().emit(name, fields || {}); } catch (_e) {}
+  try { observability().emit(name, fields || {}); } catch (_e) { /* obs best-effort */ }
 }
 
 function _stateForTest() { return STATE; }

package/lib/network-heartbeat.js

@@ -99,14 +99,14 @@ function _probeTcp(target, timeoutMs) {
     var timer = setTimeout(function () {
       if (settled) return;
       settled = true;
-      try { sock.destroy(); } catch (_e) {}
+      try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
       resolve({ ok: false, latencyMs: Date.now() - startMs, error: "timeout" });
     }, timeoutMs);
     sock.once("connect", function () {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      try { sock.end(); } catch (_e) {}
+      try { sock.end(); } catch (_e) { /* best-effort socket close */ }
       resolve({ ok: true, latencyMs: Date.now() - startMs });
     });
     sock.once("error", function (e) {
@@ -158,11 +158,11 @@ async function _runProbe(entry) {
     _emitAuditStateChange(entry, prevState);
     if (typeof entry.onStateChange === "function") {
       try { entry.onStateChange({ name: entry.target.name, prevState: prevState, state: entry.state, result: result }); }
-      catch (_e) {}
+      catch (_e) { /* operator callback best-effort */ }
     }
   }
   if (typeof entry.onResult === "function") {
-    try { entry.onResult({ name: entry.target.name, state: entry.state, result: result }); } catch (_e) {}
+    try { entry.onResult({ name: entry.target.name, state: entry.state, result: result }); } catch (_e) { /* operator callback best-effort */ }
   }
 }
 
@@ -214,7 +214,7 @@ function stop(name) {
   var entry = TARGETS.get(name);
   if (!entry) return false;
   entry.stopped = true;
-  if (entry.timer) { try { clearTimeout(entry.timer); } catch (_e) {} }
+  if (entry.timer) { try { clearTimeout(entry.timer); } catch (_e) { /* best-effort timer teardown */ } }
   TARGETS.delete(name);
   return true;
 }
@@ -251,7 +251,7 @@ function _emitObsProbe(entry, result) {
       ok:        result.ok,
       latencyMs: result.latencyMs,
     });
-  } catch (_e) {}
+  } catch (_e) { /* obs best-effort */ }
 }
 
 function _emitAuditStateChange(entry, prevState) {
@@ -272,7 +272,7 @@ function _emitAuditStateChange(entry, prevState) {
         lastResult:          entry.lastResult,
       },
     });
-  } catch (_e) {}
+  } catch (_e) { /* audit best-effort — never break the caller */ }
 }
 
 function _resetForTest() {

package/lib/network-nts.js

@@ -5,6 +5,7 @@ var dgram = require("node:dgram");
 var nodeCrypto = require("node:crypto");
 
 var C = require("./constants");
+var { timingSafeEqual } = require("./crypto");
 var validateOpts = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 
@@ -12,8 +13,28 @@ var NtsError = defineClass("NtsError", { alwaysPermanent: false });
 
 var NTS_KE_DEFAULT_PORT = 4460;
 var NTPV4_DEFAULT_PORT  = 123;
+// RFC 5905 §6 — seconds between 1900-01-01T00:00Z (NTP epoch) and
+// 1970-01-01T00:00Z (Unix epoch). Protocol-fixed (not a tunable).
 var NTP_TO_UNIX_OFFSET_SECONDS = 2208988800;
 
+// Protocol-fixed byte counts and offsets — every numeric literal that
+// represents a wire-format size or position routes through C.BYTES.bytes
+// (a value-passthrough) so the codebase has a single source of truth
+// for "what shape is this number".
+var AES_BLOCK_BYTES   = C.BYTES.bytes(16);   // AES-128/192/256 block size (RFC 3962)
+var NTP_PACKET_BYTES  = C.BYTES.bytes(48);   // RFC 5905 §7.3 packet header length
+var NTP_TX_TIMESTAMP_OFFSET = C.BYTES.bytes(40);  // RFC 5905 §7.3 — Transmit Timestamp
+var POLY1305_TAG_BYTES = C.BYTES.bytes(16);  // RFC 8439 §2.5 tag length
+var SIV_KEY_32_BYTES  = C.BYTES.bytes(32);
+var SIV_KEY_48_BYTES  = C.BYTES.bytes(48);
+var SIV_KEY_64_BYTES  = C.BYTES.bytes(64);
+var UNIQUE_ID_BYTES   = C.BYTES.bytes(32);   // RFC 8915 §5.3 unique-identifier extension
+var CHACHA20_NONCE_BYTES = C.BYTES.bytes(12);
+
+// Bits per byte — used to derive the AES key bit-width from the byte
+// length (16-byte key → 128-bit cipher → "aes-128-..." suffix).
+var BITS_PER_BYTE = 8;
+
 var REC_END                  = 0;
 var REC_NEXT_PROTOCOL        = 1;
 var REC_ERROR                = 2;
@@ -64,7 +85,9 @@ function _decodeRecords(buf) {
 }
 
 function _aesEncryptBlock(key, block) {
-  var c = nodeCrypto.createCipheriv("aes-" + (key.length * 8) + "-ecb", key, Buffer.alloc(0));
+  // key.length is in bytes (16/24/32); multiply by BITS_PER_BYTE to get
+  // the OpenSSL cipher-name suffix (128/192/256).
+  var c = nodeCrypto.createCipheriv("aes-" + (key.length * BITS_PER_BYTE) + "-ecb", key, Buffer.alloc(0));
   c.setAutoPadding(false);
   return Buffer.concat([c.update(block), c.final()]);
 }
@@ -87,7 +110,7 @@ function _xorBuf(a, b) {
 }
 
 function _cmacSubkeys(key) {
-  var L = _aesEncryptBlock(key, Buffer.alloc(16, 0));
+  var L = _aesEncryptBlock(key, Buffer.alloc(AES_BLOCK_BYTES, 0));
   var Rb = Buffer.from([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x87]);
   var K1 = _shl1(L);
   if (L[0] & 0x80) K1 = _xorBuf(K1, Rb);
@@ -98,25 +121,25 @@ function _cmacSubkeys(key) {
 
 function _cmac(key, message) {
   var subkeys = _cmacSubkeys(key);
-  var n = Math.ceil(message.length / 16);
+  var n = Math.ceil(message.length / AES_BLOCK_BYTES);
   if (n === 0) n = 1;
-  var lastIsComplete = (message.length > 0) && (message.length % 16 === 0);
+  var lastIsComplete = (message.length > 0) && (message.length % AES_BLOCK_BYTES === 0);
   var blocks = [];
   for (var i = 0; i < n - 1; i++) {
-    blocks.push(message.slice(i * 16, i * 16 + 16));
+    blocks.push(message.slice(i * AES_BLOCK_BYTES, i * AES_BLOCK_BYTES + AES_BLOCK_BYTES));
   }
   var lastBlock;
   if (lastIsComplete) {
-    lastBlock = _xorBuf(message.slice((n - 1) * 16, n * 16), subkeys.K1);
+    lastBlock = _xorBuf(message.slice((n - 1) * AES_BLOCK_BYTES, n * AES_BLOCK_BYTES), subkeys.K1);
   } else {
-    var rem = message.slice((n - 1) * 16);
-    var padded = Buffer.alloc(16);
+    var rem = message.slice((n - 1) * AES_BLOCK_BYTES);
+    var padded = Buffer.alloc(AES_BLOCK_BYTES);
     rem.copy(padded);
     padded[rem.length] = 0x80;
     lastBlock = _xorBuf(padded, subkeys.K2);
   }
   blocks.push(lastBlock);
-  var X = Buffer.alloc(16, 0);
+  var X = Buffer.alloc(AES_BLOCK_BYTES, 0);
   for (var b = 0; b < blocks.length; b++) {
     X = _aesEncryptBlock(key, _xorBuf(X, blocks[b]));
   }
@@ -131,18 +154,18 @@ function _dbl(buf) {
 }
 
 function _s2v(K, strings, plaintext) {
-  var D = _cmac(K, Buffer.alloc(16, 0));
+  var D = _cmac(K, Buffer.alloc(AES_BLOCK_BYTES, 0));
   for (var i = 0; i < strings.length; i++) {
     D = _xorBuf(_dbl(D), _cmac(K, strings[i]));
   }
   var T;
-  if (plaintext.length >= 16) {
-    var head = plaintext.slice(0, plaintext.length - 16);
-    var tail = plaintext.slice(plaintext.length - 16);
+  if (plaintext.length >= AES_BLOCK_BYTES) {
+    var head = plaintext.slice(0, plaintext.length - AES_BLOCK_BYTES);
+    var tail = plaintext.slice(plaintext.length - AES_BLOCK_BYTES);
     var xored = _xorBuf(tail, D);
     T = Buffer.concat([head, xored]);
   } else {
-    var padded = Buffer.alloc(16);
+    var padded = Buffer.alloc(AES_BLOCK_BYTES);
     plaintext.copy(padded);
     padded[plaintext.length] = 0x80;
     T = _xorBuf(_dbl(D), padded);
@@ -152,14 +175,15 @@ function _s2v(K, strings, plaintext) {
 
 function _aesCtr(key, iv, data) {
   var ivCopy = Buffer.from(iv);
+  // Clear the high bit of the 8th and 12th counter octets per RFC 5297 §2.6.
   ivCopy[8]  &= 0x7f;
   ivCopy[12] &= 0x7f;
-  var c = nodeCrypto.createCipheriv("aes-" + (key.length * 8) + "-ctr", key, ivCopy);
+  var c = nodeCrypto.createCipheriv("aes-" + (key.length * BITS_PER_BYTE) + "-ctr", key, ivCopy);
   return Buffer.concat([c.update(data), c.final()]);
 }
 
 function aesSivEncrypt(K, plaintext, associatedData) {
-  if (K.length !== 32 && K.length !== 48 && K.length !== 64) {
+  if (K.length !== SIV_KEY_32_BYTES && K.length !== SIV_KEY_48_BYTES && K.length !== SIV_KEY_64_BYTES) {
     throw new NtsError("nts/bad-key", "AES-SIV key must be 32/48/64 bytes, got " + K.length);
   }
   var half = K.length / 2;
@@ -174,11 +198,11 @@ function aesSivDecrypt(K, ciphertextWithIv, associatedData) {
   var half = K.length / 2;
   var K1 = K.slice(0, half);
   var K2 = K.slice(half);
-  var V = ciphertextWithIv.slice(0, 16);
-  var ct = ciphertextWithIv.slice(16);
+  var V = ciphertextWithIv.slice(0, AES_BLOCK_BYTES);
+  var ct = ciphertextWithIv.slice(AES_BLOCK_BYTES);
   var pt = _aesCtr(K2, V, ct);
   var Vcheck = _s2v(K1, associatedData || [], pt);
-  if (!nodeCrypto.timingSafeEqual(V, Vcheck)) {
+  if (!timingSafeEqual(V, Vcheck)) {
     throw new NtsError("nts/auth-failed", "AES-SIV authentication failed");
   }
   return pt;
@@ -207,7 +231,7 @@ function _exportKeys(socket, aeadId) {
   var label = "EXPORTER-network-time-security";
   var contextC2S = Buffer.from([0x00, 0x00, (aeadId >> 8) & 0xff, aeadId & 0xff, 0x00]);
   var contextS2C = Buffer.from([0x00, 0x00, (aeadId >> 8) & 0xff, aeadId & 0xff, 0x01]);
-  var keyLen = aeadId === AEAD_AES_SIV_CMAC_256 ? 32 : 32;
+  var keyLen = aeadId === AEAD_AES_SIV_CMAC_256 ? SIV_KEY_32_BYTES : SIV_KEY_32_BYTES;
   var c2s = socket.exportKeyingMaterial(keyLen, label, contextC2S);
   var s2c = socket.exportKeyingMaterial(keyLen, label, contextS2C);
   return { c2s: c2s, s2c: s2c };
@@ -216,9 +240,7 @@ function _exportKeys(socket, aeadId) {
 function performKeHandshake(opts) {
   opts = opts || {};
   validateOpts(opts, ["host", "port", "servername", "aead", "ca", "timeoutMs"], "nts.performKeHandshake");
-  if (typeof opts.host !== "string" || opts.host.length === 0) {
-    throw new NtsError("nts/bad-host", "nts.performKeHandshake: host required");
-  }
+  validateOpts.requireNonEmptyString(opts.host, "nts.performKeHandshake: host", NtsError, "nts/bad-host");
   var timeoutMs = opts.timeoutMs || C.TIME.seconds(10);
   return new Promise(function (resolve, reject) {
     var settled = false;
@@ -238,7 +260,7 @@ function performKeHandshake(opts) {
     if (opts.ca) connectOpts.ca = opts.ca;
     var sock = tls.connect(connectOpts);
     var timer = setTimeout(function () {
-      try { sock.destroy(); } catch (_e) {}
+      try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
       done(new NtsError("nts/ke-timeout", "NTS-KE handshake timed out after " + timeoutMs + "ms"));
     }, timeoutMs);
     timer.unref && timer.unref();
@@ -249,7 +271,7 @@ function performKeHandshake(opts) {
     sock.on("secureConnect", function () {
       if (sock.alpnProtocol !== "ntske/1") {
         clearTimeout(timer);
-        try { sock.destroy(); } catch (_e) {}
+        try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
         done(new NtsError("nts/bad-alpn",
           "NTS-KE server did not negotiate ALPN 'ntske/1', got " + JSON.stringify(sock.alpnProtocol)));
         return;
@@ -268,7 +290,7 @@ function performKeHandshake(opts) {
         clearTimeout(timer);
         var errRec  = records.find(function (r) { return r.type === REC_ERROR; });
         if (errRec) {
-          try { sock.destroy(); } catch (_e) {}
+          try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
           done(new NtsError("nts/ke-error", "NTS-KE server returned error code " + errRec.body.readUInt16BE(0)));
           return;
         }
@@ -280,20 +302,20 @@ function performKeHandshake(opts) {
         }
         var aeadRec = records.find(function (r) { return r.type === REC_AEAD_ALGORITHM; });
         if (!aeadRec || aeadRec.body.length < 2) {
-          try { sock.destroy(); } catch (_e) {}
+          try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
           done(new NtsError("nts/no-aead", "NTS-KE response missing AEAD algorithm"));
           return;
         }
         var aeadId = aeadRec.body.readUInt16BE(0);
         if (aeadId !== AEAD_AES_SIV_CMAC_256 && aeadId !== AEAD_CHACHA20_POLY1305) {
-          try { sock.destroy(); } catch (_e) {}
+          try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
           done(new NtsError("nts/unsupported-aead", "NTS-KE server selected unsupported AEAD " + aeadId));
           return;
         }
         var cookies = records.filter(function (r) { return r.type === REC_NEW_COOKIE; })
                               .map(function (r) { return r.body; });
         if (cookies.length === 0) {
-          try { sock.destroy(); } catch (_e) {}
+          try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
           done(new NtsError("nts/no-cookies", "NTS-KE response contained no cookies"));
           return;
         }
@@ -304,7 +326,7 @@ function performKeHandshake(opts) {
         var portRec = records.find(function (r) { return r.type === REC_NTPV4_PORT; });
         if (portRec && portRec.body.length >= 2) ntpPort = portRec.body.readUInt16BE(0);
         var keys = _exportKeys(sock, aeadId);
-        try { sock.end(); } catch (_e) {}
+        try { sock.end(); } catch (_e) { /* best-effort socket close */ }
         done(null, {
           aeadId:    aeadId,
           c2sKey:    keys.c2s,
@@ -316,7 +338,7 @@ function performKeHandshake(opts) {
         });
       } catch (e) {
         clearTimeout(timer);
-        try { sock.destroy(); } catch (_e) {}
+        try { sock.destroy(); } catch (_e) { /* best-effort socket teardown */ }
         done(e);
       }
     });
@@ -338,7 +360,7 @@ function _aeadEncrypt(aeadId, key, nonce, plaintext, aad) {
     return aesSivEncrypt(key, plaintext, ad);
   }
   if (aeadId === AEAD_CHACHA20_POLY1305) {
-    var c = nodeCrypto.createCipheriv("chacha20-poly1305", key, nonce, { authTagLength: 16 });
+    var c = nodeCrypto.createCipheriv("chacha20-poly1305", key, nonce, { authTagLength: POLY1305_TAG_BYTES });
     if (aad) c.setAAD(aad, { plaintextLength: plaintext.length });
     var ct = Buffer.concat([c.update(plaintext), c.final()]);
     var tag = c.getAuthTag();
@@ -353,9 +375,9 @@ function _aeadDecrypt(aeadId, key, nonce, ciphertext, aad) {
     return aesSivDecrypt(key, ciphertext, ad);
   }
   if (aeadId === AEAD_CHACHA20_POLY1305) {
-    var ct = ciphertext.slice(0, ciphertext.length - 16);
-    var tag = ciphertext.slice(ciphertext.length - 16);
-    var d = nodeCrypto.createDecipheriv("chacha20-poly1305", key, nonce, { authTagLength: 16 });
+    var ct = ciphertext.slice(0, ciphertext.length - POLY1305_TAG_BYTES);
+    var tag = ciphertext.slice(ciphertext.length - POLY1305_TAG_BYTES);
+    var d = nodeCrypto.createDecipheriv("chacha20-poly1305", key, nonce, { authTagLength: POLY1305_TAG_BYTES });
     if (aad) d.setAAD(aad, { plaintextLength: ct.length });
     d.setAuthTag(tag);
     return Buffer.concat([d.update(ct), d.final()]);
@@ -364,8 +386,8 @@ function _aeadDecrypt(aeadId, key, nonce, ciphertext, aad) {
 }
 
 function _nonceForAead(aeadId) {
-  if (aeadId === AEAD_AES_SIV_CMAC_256) return nodeCrypto.randomBytes(16);
-  return nodeCrypto.randomBytes(12);
+  if (aeadId === AEAD_AES_SIV_CMAC_256) return nodeCrypto.randomBytes(AES_BLOCK_BYTES);
+  return nodeCrypto.randomBytes(CHACHA20_NONCE_BYTES);
 }
 
 function _walkExtensions(msg, startOff) {
@@ -402,12 +424,12 @@ function querySingle(opts) {
     function done(err, result) {
       if (settled) return;
       settled = true;
-      try { sock.close(); } catch (_e) {}
+      try { sock.close(); } catch (_e) { /* best-effort socket close */ }
       if (err) reject(err); else resolve(result);
     }
-    var unique = nodeCrypto.randomBytes(32);
+    var unique = nodeCrypto.randomBytes(UNIQUE_ID_BYTES);
     var cookie = opts.cookies[0];
-    var packet = Buffer.alloc(48);
+    var packet = Buffer.alloc(NTP_PACKET_BYTES);
     packet[0] = 0x23;
     var ext1 = _encodeExtensionField(EXTENSION_UNIQUE_IDENTIFIER, unique);
     var ext2 = _encodeExtensionField(EXTENSION_NTS_COOKIE, cookie);
@@ -436,16 +458,16 @@ function querySingle(opts) {
       clearTimeout(timer);
       var receiveTimeMs = Date.now();
       try {
-        if (msg.length < 48) {
+        if (msg.length < NTP_PACKET_BYTES) {
           done(new NtsError("nts/bad-reply", "NTS reply too short"));
           return;
         }
         var exts;
-        try { exts = _walkExtensions(msg, 48); }
+        try { exts = _walkExtensions(msg, NTP_PACKET_BYTES); }
         catch (e) { done(e); return; }
         var uniqueExt = exts.find(function (e) { return e.type === EXTENSION_UNIQUE_IDENTIFIER; });
-        if (!uniqueExt || uniqueExt.body.length < 32 ||
-            !nodeCrypto.timingSafeEqual(uniqueExt.body.slice(0, 32), unique)) {
+        if (!uniqueExt || uniqueExt.body.length < UNIQUE_ID_BYTES ||
+            !timingSafeEqual(uniqueExt.body.slice(0, UNIQUE_ID_BYTES), unique)) {
           done(new NtsError("nts/unique-mismatch", "NTS reply unique-identifier mismatch (replay or spoof)"));
           return;
         }
@@ -489,11 +511,11 @@ function querySingle(opts) {
           opts.cookies.shift();
           for (var ci = 0; ci < newCookies.length; ci++) opts.cookies.push(newCookies[ci]);
         }
-        var ntpSeconds  = msg.readUInt32BE(40);
-        var ntpFraction = msg.readUInt32BE(44);
+        var ntpSeconds  = msg.readUInt32BE(NTP_TX_TIMESTAMP_OFFSET);
+        var ntpFraction = msg.readUInt32BE(NTP_TX_TIMESTAMP_OFFSET + 4);
         var serverUnixSeconds = ntpSeconds - NTP_TO_UNIX_OFFSET_SECONDS;
-        var fracMs = Math.round(ntpFraction / 0x100000000 * 1000);
-        var serverTimeMs = serverUnixSeconds * 1000 + fracMs;
+        var fracMs = Math.round(C.TIME.seconds(ntpFraction / 0x100000000));
+        var serverTimeMs = C.TIME.seconds(serverUnixSeconds) + fracMs;
         var midpointMs = sendTimeMs + (receiveTimeMs - sendTimeMs) / 2;
         var driftMs = serverTimeMs - midpointMs;
         done(null, {