@ocap/chain-node 1.32.2 → 1.32.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,17 +1,22 @@
1
1
  import { createAccessLogMiddleware } from "./access-log.mjs";
2
2
  import { fetchUpstreamChainConfig, verifyFollowerConfigAgainstUpstream } from "./config-consistency.mjs";
3
+ import { canonicalizeTlsDid, decodeEd25519PublicKeyPin, didTlsBytesToHex, issueDidTlsCertificate, parseDidTlsCertificate, verifyDidTlsPeerCertificate } from "./did-tls.mjs";
4
+ import { createChainNodePeerFetchGuard, parseMeshEgressUrl } from "./mesh-egress.mjs";
5
+ import { assertNoSymlinkAncestors } from "./env.mjs";
3
6
  import { isCompleteChainConfig, orphanIndexFromSequence, rehydrateFollowerChainConfig } from "./follower-config.mjs";
4
7
  import { assertValidChainNodeTestHooks } from "./test-hooks-token.mjs";
5
8
  import { CustomError } from "@ocap/util/lib/error";
6
- import { LeaderRouter, Ledger, bytesToHex, canonicalizeMultiCurvePublicKey, createCheckpointSigner, createEnvAnchorPublisher, createEnvColdArchiveReader, createEnvSegmentPublisher, createEnvWitnessRegistry, decodeMultiCurvePublicKey, normalizeDidForCompare, resolveConsensusProposerFromSigner, toHotStuffClusterConfig, verifyDidMatchesMultiCurvePublicKey } from "@arcblock/ledger-core";
7
- import { SqliteHotStuffStateStore, SqliteLedgerStorage, formatLocalProcessHolderId, hasExistingFollowerDatabases, persistFollowerHighWaterMark, prepareFollowerDataDirectory, readFollowerTrustedSecretKeyIfPresent, unlinkFollowerTrustedSecretKeyIfPresent } from "@arcblock/ledger-sqlite";
8
9
  import crypto from "node:crypto";
10
+ import { isValid } from "@arcblock/did";
9
11
  import fs from "node:fs";
10
12
  import path from "node:path";
11
- import { isValid } from "@arcblock/did";
13
+ import { LeaderRouter, Ledger, bytesToHex, canonicalizeMultiCurvePublicKey, createCheckpointSigner, createDaFollowerSource, createEnvAnchorPublisher, createEnvColdArchiveReader, createEnvSegmentPublisher, createEnvWitnessRegistry, daPublisherInputsFromEnv, decodeMultiCurvePublicKey, isDaArchiveMode, normalizeDidForCompare, resolveConsensusProposerFromSigner, scrubDaCredentials, toHotStuffClusterConfig, verifyDidMatchesMultiCurvePublicKey } from "@arcblock/ledger-core";
14
+ import { SqliteHotStuffStateStore, SqliteLedgerStorage, createDaResumeFileStore, formatLocalProcessHolderId, hasExistingFollowerDatabases, persistFollowerHighWaterMark, prepareFollowerDataDirectory, readFollowerTrustedSecretKeyIfPresent, unlinkFollowerTrustedSecretKeyIfPresent } from "@arcblock/ledger-sqlite";
15
+ import net from "node:net";
16
+ import OCAPResolver, { FollowerSyncService, HotStuffNodeRuntime, NodePreferencesManager, applyBootRuntimePreferences, createAdminAuthGuard, createExplorerMiddleware, createNodeDashboardRouter, createNodeMaintenanceController, createUnifiedConsoleMiddleware, isDashboardEnabled, isExplorerEnabled } from "@ocap/resolver";
17
+ import tls from "node:tls";
12
18
  import { createHttpHandler, createSocketHandler } from "@ocap/gql";
13
19
  import SqliteIndexDB from "@ocap/indexdb-sqlite";
14
- import OCAPResolver, { FollowerSyncService, HotStuffNodeRuntime, NodePreferencesManager, applyBootRuntimePreferences, createAdminAuthGuard, createExplorerMiddleware, createFollowerPeerFetchGuard, createNodeDashboardRouter, createNodeMaintenanceController, createUnifiedConsoleMiddleware, isDashboardEnabled, isExplorerEnabled } from "@ocap/resolver";
15
20
  import { createAPIHandler } from "@ocap/resolver/api";
16
21
  import { Blacklist } from "@ocap/state";
17
22
  import SqliteStateDB from "@ocap/statedb-sqlite";
@@ -23,7 +28,132 @@ import express from "express";
23
28
  const CHAIN_STATE_ADDR = crypto.createHash("md5").update("OCAP_CHAIN_ADDR").digest("hex");
24
29
  const NODE_ID_FILENAME = ".node-id";
25
30
  const DEFAULT_DRAIN_TIMEOUT_MS = 5e3;
31
+ const DEFAULT_TLS_HANDSHAKE_TIMEOUT_MS = 1e4;
32
+ const MAX_TLS_CREDENTIAL_FILE_BYTES = 65536;
26
33
  const FORMATTED_HOLDER_ID_RE = /:\d+:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
34
+ function readNonSymlinkRegularFileUtf8(rawPath, label) {
35
+ const resolved = path.resolve(rawPath.trim());
36
+ assertNoSymlinkAncestors(resolved, label);
37
+ let lstat;
38
+ try {
39
+ lstat = fs.lstatSync(resolved);
40
+ } catch (err) {
41
+ throw new CustomError("INVALID_CONFIG", `${label} file not found (${resolved}): ${err?.code || "ENOENT"}`);
42
+ }
43
+ if (lstat.isSymbolicLink()) throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked ${label} file: ${resolved}`);
44
+ if (!lstat.isFile()) throw new CustomError("INVALID_CONFIG", `${label} must be a regular file: ${resolved}`);
45
+ if (lstat.size === 0 || lstat.size > MAX_TLS_CREDENTIAL_FILE_BYTES) throw new CustomError("INVALID_CONFIG", `${label} file size (${lstat.size}B) out of range 1..${MAX_TLS_CREDENTIAL_FILE_BYTES}`);
46
+ const openFlags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);
47
+ let fd;
48
+ try {
49
+ fd = fs.openSync(resolved, openFlags);
50
+ } catch (err) {
51
+ if (err?.code === "ELOOP") throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked ${label} file: ${resolved}`);
52
+ throw new CustomError("INVALID_CONFIG", `Failed to open ${label} file (${resolved}): ${err?.code || "EIO"}`);
53
+ }
54
+ try {
55
+ const fstat = fs.fstatSync(fd);
56
+ if (!fstat.isFile() || fstat.size === 0 || fstat.size > MAX_TLS_CREDENTIAL_FILE_BYTES) throw new CustomError("INVALID_CONFIG", `Invalid ${label} file descriptor state: ${resolved}`);
57
+ const buf = new Uint8Array(fstat.size);
58
+ const bytesRead = fs.readSync(fd, buf, 0, fstat.size, 0);
59
+ return new TextDecoder().decode(buf.subarray(0, bytesRead));
60
+ } finally {
61
+ fs.closeSync(fd);
62
+ }
63
+ }
64
+ function buildChainTlsSecureContextOptions(certPem, keyPem) {
65
+ return {
66
+ minVersion: "TLSv1.3",
67
+ maxVersion: "TLSv1.3",
68
+ secureOptions: crypto.constants.SSL_OP_NO_TICKET,
69
+ cert: certPem,
70
+ key: keyPem
71
+ };
72
+ }
73
+ function countPinnedIssuers(pins) {
74
+ if (!pins) return 0;
75
+ if (pins instanceof Map) {
76
+ for (const [didKey, pkVal] of pins.entries()) {
77
+ canonicalizeTlsDid(didKey, "allowedIssuerPublicKeys DID");
78
+ decodeEd25519PublicKeyPin(pkVal, "allowedIssuerPublicKeys pubkey");
79
+ }
80
+ return pins.size;
81
+ }
82
+ if (Array.isArray(pins) || pins instanceof Set) {
83
+ let count = 0;
84
+ for (const item of pins) {
85
+ if (typeof item === "string" && item.includes("=")) {
86
+ const eq = item.indexOf("=");
87
+ canonicalizeTlsDid(item.slice(0, eq), "allowedIssuerPublicKeys DID");
88
+ decodeEd25519PublicKeyPin(item.slice(eq + 1), "allowedIssuerPublicKeys pubkey");
89
+ } else decodeEd25519PublicKeyPin(item, "allowedIssuerPublicKeys pubkey");
90
+ count++;
91
+ }
92
+ return count;
93
+ }
94
+ if (typeof pins === "object") {
95
+ const entries = Object.entries(pins);
96
+ for (const [didKey, pkVal] of entries) {
97
+ canonicalizeTlsDid(didKey, "allowedIssuerPublicKeys DID");
98
+ decodeEd25519PublicKeyPin(pkVal, "allowedIssuerPublicKeys pubkey");
99
+ }
100
+ return entries.length;
101
+ }
102
+ return 0;
103
+ }
104
+ function validateChainHttpTlsConfig(rawTls) {
105
+ if (!rawTls?.enabled) return null;
106
+ const wireAlgorithm = rawTls.wireAlgorithm ?? "p256";
107
+ if (wireAlgorithm !== "ed25519" && wireAlgorithm !== "p256") throw new CustomError("INVALID_CONFIG", `Invalid http.tls.wireAlgorithm="${String(wireAlgorithm)}"`);
108
+ const requireClientCert = rawTls.requireClientCert !== false;
109
+ const handshakeTimeoutMs = typeof rawTls.handshakeTimeoutMs === "number" && Number.isFinite(rawTls.handshakeTimeoutMs) && rawTls.handshakeTimeoutMs >= 500 ? Math.trunc(rawTls.handshakeTimeoutMs) : DEFAULT_TLS_HANDSHAKE_TIMEOUT_MS;
110
+ const certFile = rawTls.certFile?.trim() || void 0;
111
+ const keyFile = rawTls.keyFile?.trim() || void 0;
112
+ if (Boolean(certFile) !== Boolean(keyFile)) throw new CustomError("INVALID_CONFIG", "http.tls.certFile and http.tls.keyFile must both be provided together");
113
+ if (certFile && keyFile) {
114
+ readNonSymlinkRegularFileUtf8(certFile, "http.tls.certFile");
115
+ readNonSymlinkRegularFileUtf8(keyFile, "http.tls.keyFile");
116
+ }
117
+ let pinCount = 0;
118
+ try {
119
+ pinCount = countPinnedIssuers(rawTls.allowedIssuerPublicKeys);
120
+ } catch (err) {
121
+ throw new CustomError("INVALID_CONFIG", `Invalid http.tls.allowedIssuerPublicKeys: ${err instanceof Error ? err.message : String(err)}`);
122
+ }
123
+ if (requireClientCert && pinCount === 0) throw new CustomError("INVALID_CONFIG", "DID-TLS requireClientCert=true requires at least one pinned Ed25519 key in http.tls.allowedIssuerPublicKeys");
124
+ const allowedClientDids = [];
125
+ for (const rawDid of rawTls.allowedClientDids ?? []) try {
126
+ allowedClientDids.push(canonicalizeTlsDid(rawDid, "http.tls.allowedClientDids"));
127
+ } catch (err) {
128
+ throw new CustomError("INVALID_CONFIG", `Invalid DID in http.tls.allowedClientDids: ${err instanceof Error ? err.message : String(err)}`);
129
+ }
130
+ let subjectDid;
131
+ if (rawTls.subjectDid?.trim()) try {
132
+ subjectDid = canonicalizeTlsDid(rawTls.subjectDid, "http.tls.subjectDid");
133
+ } catch (err) {
134
+ throw new CustomError("INVALID_CONFIG", `Invalid http.tls.subjectDid: ${err instanceof Error ? err.message : String(err)}`);
135
+ }
136
+ return {
137
+ enabled: true,
138
+ wireAlgorithm,
139
+ requireClientCert,
140
+ hasConfiguredClientTrustPins: pinCount > 0,
141
+ handshakeTimeoutMs,
142
+ ...certFile ? { certFile } : {},
143
+ ...keyFile ? { keyFile } : {},
144
+ ...rawTls.identitySecretKey?.trim() ? { identitySecretKey: rawTls.identitySecretKey.trim() } : {},
145
+ ...subjectDid ? { subjectDid } : {},
146
+ sanDnsNames: rawTls.sanDnsNames ?? [],
147
+ sanIpAddresses: rawTls.sanIpAddresses ?? [],
148
+ ...rawTls.validityDays !== void 0 ? { validityDays: rawTls.validityDays } : {},
149
+ basePeerPolicy: {
150
+ allowedIssuerPublicKeys: rawTls.allowedIssuerPublicKeys,
151
+ ...allowedClientDids.length > 0 ? { allowedSubjectDids: allowedClientDids } : {},
152
+ expectedRole: "client",
153
+ ...rawTls.clockSkewSeconds !== void 0 ? { clockSkewSeconds: rawTls.clockSkewSeconds } : {}
154
+ }
155
+ };
156
+ }
27
157
  function createDefaultLogger(prefix = "chain-node") {
28
158
  return {
29
159
  info: (...args) => console.info(`[${prefix}]`, ...args),
@@ -54,27 +184,54 @@ function classifyFetchKind(rawUrl) {
54
184
  }
55
185
  function assertSafeNonSymlinkDirectory(rawDataDir) {
56
186
  const dataDir = path.resolve(rawDataDir);
57
- if (fs.existsSync(dataDir)) {
58
- if (fs.lstatSync(dataDir).isSymbolicLink()) throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked chain node dataDir: ${dataDir}`);
59
- } else fs.mkdirSync(dataDir, { recursive: true });
60
- if (fs.lstatSync(dataDir).isSymbolicLink()) throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked chain node dataDir: ${dataDir}`);
187
+ assertNoSymlinkAncestors(dataDir, "dataDir");
188
+ if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
189
+ assertNoSymlinkAncestors(dataDir, "dataDir");
190
+ if (!fs.lstatSync(dataDir).isDirectory()) throw new CustomError("INVALID_CONFIG", `Chain node dataDir is not a directory: ${dataDir}`);
61
191
  return dataDir;
62
192
  }
63
- /** Write a small file and fsync it and its directory, so it survives a crash or power loss right after. */
193
+ /**
194
+ * Write a small file atomically and durably (`wx` `0o600` temp file + `fsync` + `rename` + parent dir `fsync`),
195
+ * refusing symlinks on both the target file and its immediate parent directory (#2026, #2036, #2039).
196
+ */
64
197
  function writeFileDurably(filePath, content) {
65
- const fd = fs.openSync(filePath, "w", 384);
198
+ const resolved = path.resolve(filePath);
199
+ const parentDir = path.dirname(resolved);
200
+ const parentSt = fs.lstatSync(parentDir);
201
+ if (parentSt.isSymbolicLink() || !parentSt.isDirectory()) throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked or non-directory parent: ${parentDir}`);
202
+ const assertTargetNotSymlink = () => {
203
+ try {
204
+ if (fs.lstatSync(resolved).isSymbolicLink()) throw new CustomError("SECURITY_VIOLATION", `Refusing symlinked target file: ${resolved}`);
205
+ } catch (err) {
206
+ if (err?.code !== "ENOENT") throw err;
207
+ }
208
+ };
209
+ assertTargetNotSymlink();
210
+ const tmpPath = `${resolved}.tmp.${process.pid}.${crypto.randomBytes(6).toString("hex")}`;
211
+ const fd = fs.openSync(tmpPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW ?? 0), 384);
212
+ let closed = false;
66
213
  try {
67
214
  fs.writeFileSync(fd, content);
68
215
  fs.fsyncSync(fd);
69
- } finally {
70
216
  fs.closeSync(fd);
217
+ closed = true;
218
+ assertTargetNotSymlink();
219
+ fs.renameSync(tmpPath, resolved);
220
+ } catch (err) {
221
+ if (!closed) try {
222
+ fs.closeSync(fd);
223
+ } catch {}
224
+ fs.rmSync(tmpPath, { force: true });
225
+ throw err;
71
226
  }
72
- const dirFd = fs.openSync(path.dirname(filePath), "r");
73
227
  try {
74
- fs.fsyncSync(dirFd);
75
- } finally {
76
- fs.closeSync(dirFd);
77
- }
228
+ const dirFd = fs.openSync(parentDir, "r");
229
+ try {
230
+ fs.fsyncSync(dirFd);
231
+ } finally {
232
+ fs.closeSync(dirFd);
233
+ }
234
+ } catch {}
78
235
  }
79
236
  function loadOrCreateNodeId(dataDir, explicitNodeId) {
80
237
  const nodeIdPath = path.join(dataDir, NODE_ID_FILENAME);
@@ -137,6 +294,10 @@ function buildFollowerNodeRoleConfig(role, resolvedSigner) {
137
294
  upstreamChainUrl: role.upstreamChainUrl ?? null,
138
295
  clusterPeerUrls: role.clusterPeerUrls ?? [],
139
296
  snapshotBaseUrl: role.snapshotBaseUrl ?? null,
297
+ ...role.bootstrapSource ? { bootstrapSource: role.bootstrapSource } : {},
298
+ ...role.da ? { da: role.da } : {},
299
+ ...role.daCrossCheck ? { daCrossCheck: role.daCrossCheck } : {},
300
+ ...role.daCrossCheckIncomplete ? { daCrossCheckIncomplete: role.daCrossCheckIncomplete } : {},
140
301
  trustedProposer: isHotStuffCluster ? null : hasExplicitTrustedAnchor ? role.trustedProposer ?? null : resolvedSigner?.address ?? null,
141
302
  trustedProposerPublicKey: isHotStuffCluster ? null : hasExplicitTrustedAnchor ? role.trustedProposerPublicKey ?? null : resolvedSigner?.publicKey ?? null,
142
303
  allowUnauthenticatedBootstrap: Boolean(role.allowUnauthenticatedBootstrap),
@@ -196,6 +357,8 @@ async function bootChainNodeOnce(params) {
196
357
  if ((role.kind === "validator" || role.kind === "hotstuff") && !role.signer) throw new CustomError("INVALID_CONFIG", `${role.kind} role requires role.signer`);
197
358
  if (role.kind === "hotstuff" && (!Array.isArray(role.validators) || role.validators.length === 0)) throw new CustomError("INVALID_CONFIG", "HotStuff role requires a non-empty validators list");
198
359
  if (role.kind === "follower" && role.orphanIndexFromSequence !== void 0 && (!Number.isSafeInteger(role.orphanIndexFromSequence) || role.orphanIndexFromSequence < 1)) throw new CustomError("INVALID_CONFIG", `role.orphanIndexFromSequence must be a positive integer, got ${String(role.orphanIndexFromSequence)}`);
360
+ const effectiveMeshEgress = parseMeshEgressUrl(profile.meshEgressUrl ?? ("meshEgressUrl" in role ? role.meshEgressUrl : void 0), "meshEgressUrl");
361
+ const validatedTls = validateChainHttpTlsConfig(profile.http?.tls);
199
362
  const logger = testHooks?.logger ?? profile.logger ?? createDefaultLogger("chain-node");
200
363
  const variadicLogger = toVariadicLogger(logger);
201
364
  const followerExpectedChainId = "expectedChainId" in profile ? profile.expectedChainId : void 0;
@@ -262,13 +425,17 @@ async function bootChainNodeOnce(params) {
262
425
  ledgerCleanupIndex = -1;
263
426
  }
264
427
  }
265
- const guardedBootstrapFetch = createFollowerPeerFetchGuard({
266
- env: { ALLOW_PRIVATE_PEER_URLS: role.allowPrivatePeers ? "1" : "0" },
267
- trustedStaticUrls: [
268
- role.upstreamChainUrl,
269
- role.snapshotBaseUrl,
270
- ...role.clusterPeerUrls ?? []
271
- ].filter((u) => Boolean(u && String(u).trim())),
428
+ const staticTrustedUrls = [
429
+ role.upstreamChainUrl,
430
+ role.snapshotBaseUrl,
431
+ role.da?.baseUrl,
432
+ role.daCrossCheck?.baseUrl,
433
+ ...role.clusterPeerUrls ?? []
434
+ ].filter((u) => Boolean(u && String(u).trim()));
435
+ const guardedBootstrapFetch = createChainNodePeerFetchGuard({
436
+ allowPrivatePeers: role.allowPrivatePeers,
437
+ meshEgress: effectiveMeshEgress,
438
+ trustedStaticUrls: staticTrustedUrls,
272
439
  baseFetch: globalThis.fetch
273
440
  });
274
441
  const interceptFetch = testHooks?.followerSync?.interceptUpstreamFetch;
@@ -293,7 +460,8 @@ async function bootChainNodeOnce(params) {
293
460
  ledgerPath,
294
461
  trustedPath,
295
462
  keyless: isKeylessFollower,
296
- fetchImpl: bootstrapFetchImpl
463
+ fetchImpl: bootstrapFetchImpl,
464
+ logger: { warn: (...args) => variadicLogger.warn(...args) }
297
465
  });
298
466
  }
299
467
  if (!ledgerStorage) {
@@ -375,12 +543,28 @@ async function bootChainNodeOnce(params) {
375
543
  const hotstuffValidators = role.kind === "hotstuff" ? role.validators : role.kind === "follower" ? role.hotstuffValidators ?? [] : [];
376
544
  const hotstuffQuorumThreshold = role.kind === "hotstuff" ? role.quorumThreshold : role.kind === "follower" ? role.hotstuffQuorumThreshold : void 0;
377
545
  const hotstuffClusterConfig = role.kind === "hotstuff" || hotstuffValidators.length > 0 ? toHotStuffClusterConfig(chainConfig.chainId, hotstuffValidators, hotstuffQuorumThreshold) : void 0;
378
- const segmentPublisher = profile.da?.segmentPublisher !== void 0 ? profile.da.segmentPublisher : role.kind !== "follower" && profile.da?.env ? createEnvSegmentPublisher({
546
+ const daModeFromEnv = profile.da?.segmentPublisher === void 0 && role.kind !== "follower" && Boolean(profile.da?.env) && isDaArchiveMode(profile.da.env);
547
+ const daPublisherInputs = daModeFromEnv && role.kind === "validator" && resolvedProposer ? daPublisherInputsFromEnv({
379
548
  env: profile.da.env,
549
+ chainId: chainConfig.chainId,
550
+ wallet: resolvedProposer.proposerWallet,
551
+ retentionMode: role.retentionMode ?? "archive",
552
+ resumeStore: createDaResumeFileStore(path.join(dataDir, "da-publisher-resume.json")),
380
553
  logger: variadicLogger
554
+ }) : {};
555
+ const segmentPublisher = profile.da?.segmentPublisher !== void 0 ? profile.da.segmentPublisher : role.kind !== "follower" && profile.da?.env ? createEnvSegmentPublisher({
556
+ env: profile.da.env,
557
+ logger: variadicLogger,
558
+ ...daPublisherInputs,
559
+ ...profile.da.fetchImpl ? { fetchImpl: profile.da.fetchImpl } : {}
381
560
  }) : null;
382
561
  const explicitColdReader = profile.da?.coldArchiveReader ?? null;
383
- const envColdReader = !explicitColdReader && profile.da?.env ? createEnvColdArchiveReader({ env: profile.da.env }) : null;
562
+ const followsDaArchive = role.kind === "follower" && role.bootstrapSource === "da";
563
+ const envColdReader = !explicitColdReader && profile.da?.env && !daModeFromEnv && !followsDaArchive ? createEnvColdArchiveReader({
564
+ env: profile.da.env,
565
+ logger: variadicLogger
566
+ }) : null;
567
+ scrubDaCredentials(profile.da?.env);
384
568
  const coldSegmentStore = explicitColdReader ? adaptColdReaderToArchiveStore(explicitColdReader) : segmentPublisher?.getArchiveStore?.() || (envColdReader ? adaptColdReaderToArchiveStore(envColdReader) : void 0);
385
569
  const hasExplicitTrustedAnchor = role.kind === "follower" && (role.trustedProposer != null || role.trustedProposerPublicKey != null);
386
570
  const followerExplicitPk = role.kind === "follower" ? followerPrep?.trustedProposerPublicKey || role.trustedProposerPublicKey || null : null;
@@ -640,7 +824,24 @@ async function bootChainNodeOnce(params) {
640
824
  trustedProposerPublicKey: followerPrep?.trustedProposerPublicKey || role.trustedProposerPublicKey || void 0,
641
825
  allowUnauthenticatedLeaderFailover: Boolean(role.allowUnauthenticatedBootstrap)
642
826
  }) : void 0;
643
- const coldReaderForFollower = explicitColdReader ?? envColdReader ?? void 0;
827
+ const guardedFollowerRuntimeFetch = createChainNodePeerFetchGuard({
828
+ allowPrivatePeers: role.allowPrivatePeers,
829
+ meshEgress: effectiveMeshEgress,
830
+ trustedStaticUrls: [
831
+ role.upstreamChainUrl,
832
+ role.snapshotBaseUrl,
833
+ role.da?.baseUrl,
834
+ ...mergedPeerUrls,
835
+ ...role.witnessSubmitUrls ?? []
836
+ ],
837
+ baseFetch: globalThis.fetch
838
+ });
839
+ const coldReaderForFollower = (role.bootstrapSource === "da" && role.da ? createDaFollowerSource({
840
+ da: role.da,
841
+ proposer: role.trustedProposer ?? "",
842
+ proposerPublicKey: role.trustedProposerPublicKey ?? "",
843
+ fetchImpl: guardedFollowerRuntimeFetch
844
+ }) : null)?.reader ?? explicitColdReader ?? envColdReader ?? void 0;
644
845
  followerSync = new FollowerSyncService({
645
846
  resolver,
646
847
  role: role.runtimeRole ?? "follower",
@@ -666,6 +867,7 @@ async function bootChainNodeOnce(params) {
666
867
  maxUpstreamStaleMs: role.maxUpstreamStaleMs,
667
868
  startPaused: testHooks?.followerSync?.startPaused,
668
869
  artificialPollDelayMs: testHooks?.followerSync?.artificialPollDelayMs,
870
+ fetchImpl: guardedFollowerRuntimeFetch,
669
871
  interceptUpstreamFetch: testHooks?.followerSync?.interceptUpstreamFetch,
670
872
  ...profile.replayGuards?.futureTimestamp ? { futureTimestampGuard: {
671
873
  ...profile.replayGuards.futureTimestamp,
@@ -700,6 +902,23 @@ async function bootChainNodeOnce(params) {
700
902
  }
701
903
  } else if (role.kind === "hotstuff") {
702
904
  const hotstuffStateStore = new SqliteHotStuffStateStore(ledgerStorage);
905
+ const guardedHotStuffFetch = createChainNodePeerFetchGuard({
906
+ allowPrivatePeers: role.allowPrivatePeers,
907
+ meshEgress: effectiveMeshEgress,
908
+ trustedStaticUrls: role.validators.flatMap((v) => [v.rpcUrl, v.consensusUrl]),
909
+ baseFetch: globalThis.fetch
910
+ });
911
+ const selfValidatorDid = resolvedProposer.address.trim();
912
+ const allHttpPeersMatchMeshEgress = effectiveMeshEgress !== null && role.validators.every((v) => {
913
+ if (v.did.trim() === selfValidatorDid) return true;
914
+ try {
915
+ const parsedConsensus = new URL(v.consensusUrl);
916
+ if (parsedConsensus.protocol === "https:") return true;
917
+ return parsedConsensus.origin.toLowerCase() === effectiveMeshEgress.origin;
918
+ } catch {
919
+ return false;
920
+ }
921
+ });
703
922
  hotstuffRuntime = new HotStuffNodeRuntime({
704
923
  resolver,
705
924
  validatorDid: resolvedProposer.address,
@@ -710,9 +929,10 @@ async function bootChainNodeOnce(params) {
710
929
  consensusBindHost: role.consensusBindHost,
711
930
  consensusPort: role.consensusPort,
712
931
  allowPublicBind: Boolean(role.allowPublicConsensusBind),
713
- allowPrivateHttpPeers: Boolean(role.allowPrivatePeers),
932
+ allowPrivateHttpPeers: Boolean(role.allowPrivatePeers || allHttpPeersMatchMeshEgress),
714
933
  writePolicy: role.writePolicy ?? "forward",
715
934
  stateStore: hotstuffStateStore,
935
+ fetchImpl: guardedHotStuffFetch,
716
936
  onOutboundConsensusRequest: testHooks?.hotstuff?.onOutboundConsensusRequest ?? testHooks?.hotstuff?.interceptOutboundRpc
717
937
  });
718
938
  resolver.setNodeRuntime(hotstuffRuntime);
@@ -816,9 +1036,11 @@ async function bootChainNodeOnce(params) {
816
1036
  });
817
1037
  pushCleanup(async () => {
818
1038
  isShuttingDown = true;
819
- await new Promise((resolveClose) => {
1039
+ server.closeAllConnections?.();
1040
+ if (server.listening) await new Promise((resolveClose) => {
820
1041
  server.close(() => resolveClose());
821
1042
  });
1043
+ else server.close();
822
1044
  });
823
1045
  app.use("/api", createAPIHandler({
824
1046
  resolver,
@@ -855,24 +1077,513 @@ async function bootChainNodeOnce(params) {
855
1077
  const bindHost = profile.http.host?.trim() || "127.0.0.1";
856
1078
  const requestedPort = profile.http.port;
857
1079
  if (!Number.isSafeInteger(requestedPort) || requestedPort < 0 || requestedPort > 65535) throw new CustomError("INVALID_CONFIG", `Invalid http.port="${String(requestedPort)}": expected 0..65535`);
858
- await new Promise((resolveListen, rejectListen) => {
859
- const onError = (err) => {
860
- server.off("listening", onListening);
861
- rejectListen(err);
1080
+ let tlsServer;
1081
+ let publicTcpServer;
1082
+ const retiredTlsServers = /* @__PURE__ */ new Set();
1083
+ const activeTlsSockets = /* @__PURE__ */ new Set();
1084
+ const activeRawSockets = /* @__PURE__ */ new Set();
1085
+ const bridgeSockets = /* @__PURE__ */ new Set();
1086
+ const handshakeTimers = /* @__PURE__ */ new Map();
1087
+ const admittedBridgeByClientPort = /* @__PURE__ */ new Map();
1088
+ let reloadTlsCredentials = async () => ({
1089
+ reloaded: false,
1090
+ subjectDid: null,
1091
+ spkiSha256Hex: null
1092
+ });
1093
+ const closeAllTlsNetworking = async () => {
1094
+ for (const timer of handshakeTimers.values()) clearTimeout(timer);
1095
+ handshakeTimers.clear();
1096
+ for (const bSock of Array.from(bridgeSockets)) bSock.destroy();
1097
+ bridgeSockets.clear();
1098
+ admittedBridgeByClientPort.clear();
1099
+ for (const sock of Array.from(activeTlsSockets)) sock.destroy();
1100
+ activeTlsSockets.clear();
1101
+ for (const rawSock of Array.from(activeRawSockets)) rawSock.destroy();
1102
+ activeRawSockets.clear();
1103
+ const closeTasks = [];
1104
+ if (publicTcpServer?.listening) {
1105
+ const tcpSrv = publicTcpServer;
1106
+ closeTasks.push(new Promise((r) => tcpSrv.close(() => r())));
1107
+ }
1108
+ for (const oldTls of Array.from(retiredTlsServers)) if (oldTls.listening) closeTasks.push(new Promise((r) => oldTls.close(() => r())));
1109
+ retiredTlsServers.clear();
1110
+ if (tlsServer?.listening) {
1111
+ const activeSrv = tlsServer;
1112
+ closeTasks.push(new Promise((r) => activeSrv.close(() => r())));
1113
+ }
1114
+ server.closeAllConnections?.();
1115
+ if (server.listening) closeTasks.push(new Promise((r) => server.close(() => r())));
1116
+ else server.close();
1117
+ await Promise.all(closeTasks);
1118
+ };
1119
+ const loadOrSynthesizeTlsMaterial = () => {
1120
+ if (!validatedTls) throw new CustomError("INVALID_STATE", "TLS is not enabled on this chain node");
1121
+ if (validatedTls.certFile && validatedTls.keyFile) {
1122
+ const certPem = readNonSymlinkRegularFileUtf8(validatedTls.certFile, "http.tls.certFile");
1123
+ const keyPem = readNonSymlinkRegularFileUtf8(validatedTls.keyFile, "http.tls.keyFile");
1124
+ let subjectDid = null;
1125
+ let spkiSha256Hex = null;
1126
+ try {
1127
+ const parsed = parseDidTlsCertificate(certPem);
1128
+ subjectDid = parsed.subjectDid;
1129
+ spkiSha256Hex = didTlsBytesToHex(new Uint8Array(crypto.createHash("sha256").update(parsed.spkiDer).digest()));
1130
+ } catch {
1131
+ try {
1132
+ const spkiDer = new crypto.X509Certificate(certPem).publicKey.export({
1133
+ format: "der",
1134
+ type: "spki"
1135
+ });
1136
+ spkiSha256Hex = crypto.createHash("sha256").update(new Uint8Array(spkiDer)).digest("hex");
1137
+ } catch {}
1138
+ }
1139
+ return {
1140
+ certPem,
1141
+ keyPem,
1142
+ subjectDid,
1143
+ spkiSha256Hex
1144
+ };
1145
+ }
1146
+ const proposerEd25519Sk = resolvedProposer?.signatureKeyType === "ed25519" ? resolvedProposer.secretKey : void 0;
1147
+ const rawSeed = validatedTls.identitySecretKey || proposerEd25519Sk || profile.storage?.trustedStorageSecretKey?.trim() || trustedSecretKey;
1148
+ if (!rawSeed) throw new CustomError("INVALID_CONFIG", "DID-TLS server certificate synthesis requires an Ed25519 secret key (CHAIN_SK / signer.secretKey / http.tls.identitySecretKey)");
1149
+ const issued = issueDidTlsCertificate({
1150
+ subjectSeed: rawSeed,
1151
+ subjectDid: validatedTls.subjectDid ?? (proposerEd25519Sk && rawSeed === proposerEd25519Sk ? canonicalizeTlsDid(resolvedProposer.address) : void 0),
1152
+ wireAlgorithm: validatedTls.wireAlgorithm,
1153
+ role: "server",
1154
+ dnsNames: validatedTls.sanDnsNames,
1155
+ ipAddresses: validatedTls.sanIpAddresses,
1156
+ notBefore: new Date(clockNow()),
1157
+ ...validatedTls.validityDays !== void 0 ? { validityDays: validatedTls.validityDays } : {}
1158
+ });
1159
+ return {
1160
+ certPem: issued.certificatePem,
1161
+ keyPem: issued.privateKeyPem,
1162
+ subjectDid: issued.subjectDid,
1163
+ spkiSha256Hex: issued.spkiSha256Hex
862
1164
  };
863
- const onListening = () => {
864
- server.off("error", onError);
865
- resolveListen();
1165
+ };
1166
+ let boundPort;
1167
+ if (validatedTls) {
1168
+ const MAX_PRE_BRIDGE_BUFFER_BYTES = 65536;
1169
+ const GATED_HTTP_DISPATCH_EVENTS = new Set([
1170
+ "request",
1171
+ "upgrade",
1172
+ "checkContinue",
1173
+ "checkExpectation",
1174
+ "connect",
1175
+ "dropRequest"
1176
+ ]);
1177
+ const initialMaterial = loadOrSynthesizeTlsMaterial();
1178
+ const shouldRequestClientCert = validatedTls.requireClientCert || validatedTls.hasConfiguredClientTrustPins;
1179
+ const needsLoopbackHttpBridge = server.listenerCount("connection") === 0;
1180
+ const needsAtomicTlsSwap = needsLoopbackHttpBridge || Boolean(process.versions.bun);
1181
+ let internalHttpPort = 0;
1182
+ let internalTlsPort = 0;
1183
+ if (needsLoopbackHttpBridge) {
1184
+ const isLoopbackRemoteAddress = (addr) => addr === "127.0.0.1" || addr === "::ffff:127.0.0.1";
1185
+ const verifyAndBindServerSocket = (srvSock) => {
1186
+ if (!srvSock || !isLoopbackRemoteAddress(srvSock.remoteAddress)) return;
1187
+ const remotePort = srvSock.remotePort;
1188
+ if (typeof remotePort !== "number" || remotePort <= 0) return;
1189
+ const entry = admittedBridgeByClientPort.get(remotePort);
1190
+ if (!entry || entry.bridgeSock.destroyed) return;
1191
+ if (entry.boundServerSocket && entry.boundServerSocket !== srvSock) return;
1192
+ if (!entry.boundServerSocket) {
1193
+ entry.boundServerSocket = srvSock;
1194
+ const revokePortEntry = () => {
1195
+ if (admittedBridgeByClientPort.get(remotePort) === entry) admittedBridgeByClientPort.delete(remotePort);
1196
+ };
1197
+ srvSock.once("close", revokePortEntry);
1198
+ const origDestroy = srvSock.destroy.bind(srvSock);
1199
+ srvSock.destroy = ((error) => {
1200
+ revokePortEntry();
1201
+ return origDestroy(error);
1202
+ });
1203
+ }
1204
+ return entry;
1205
+ };
1206
+ const origEmit = server.emit.bind(server);
1207
+ server.emit = ((event, ...args) => {
1208
+ if (event === "connection") {
1209
+ const srvSock = args[0];
1210
+ if (!verifyAndBindServerSocket(srvSock)) {
1211
+ srvSock?.destroy();
1212
+ return false;
1213
+ }
1214
+ return origEmit(event, ...args);
1215
+ }
1216
+ if (GATED_HTTP_DISPATCH_EVENTS.has(event)) {
1217
+ const req = args[0];
1218
+ const extraSock = event === "upgrade" || event === "connect" || event === "dropRequest" ? args[1] : void 0;
1219
+ const reqSock = req?.socket ?? extraSock;
1220
+ const entry = verifyAndBindServerSocket(reqSock);
1221
+ if (!entry) {
1222
+ extraSock?.destroy();
1223
+ req?.socket?.destroy();
1224
+ return false;
1225
+ }
1226
+ if (entry.peer && reqSock) reqSock.didTlsPeer = entry.peer;
1227
+ }
1228
+ return origEmit(event, ...args);
1229
+ });
1230
+ }
1231
+ const registerRawSocketTimer = (rawSocket) => {
1232
+ if (isShuttingDown) {
1233
+ rawSocket.destroy();
1234
+ return;
1235
+ }
1236
+ activeRawSockets.add(rawSocket);
1237
+ const timer = setTimeout(() => {
1238
+ handshakeTimers.delete(rawSocket);
1239
+ rawSocket.destroy();
1240
+ }, validatedTls.handshakeTimeoutMs);
1241
+ if (typeof timer.unref === "function") timer.unref();
1242
+ handshakeTimers.set(rawSocket, timer);
1243
+ rawSocket.once("close", () => {
1244
+ const pendingTimer = handshakeTimers.get(rawSocket);
1245
+ if (pendingTimer) {
1246
+ clearTimeout(pendingTimer);
1247
+ handshakeTimers.delete(rawSocket);
1248
+ }
1249
+ activeRawSockets.delete(rawSocket);
1250
+ });
1251
+ rawSocket.on("error", () => {
1252
+ rawSocket.destroy();
1253
+ });
866
1254
  };
867
- server.once("error", onError);
868
- server.once("listening", onListening);
869
- server.listen(requestedPort, bindHost);
870
- });
871
- const addressInfo = server.address();
872
- const boundPort = addressInfo && typeof addressInfo === "object" && typeof addressInfo.port === "number" ? addressInfo.port : requestedPort;
1255
+ const clearRawSocketTimer = (rawSocket) => {
1256
+ if (!rawSocket) return;
1257
+ const pendingTimer = handshakeTimers.get(rawSocket);
1258
+ if (pendingTimer) {
1259
+ clearTimeout(pendingTimer);
1260
+ handshakeTimers.delete(rawSocket);
1261
+ }
1262
+ };
1263
+ const createConfiguredTlsServer = (certPem, keyPem) => {
1264
+ const srv = tls.createServer({
1265
+ ...buildChainTlsSecureContextOptions(certPem, keyPem),
1266
+ requestCert: shouldRequestClientCert,
1267
+ rejectUnauthorized: false,
1268
+ handshakeTimeout: validatedTls.handshakeTimeoutMs
1269
+ });
1270
+ srv.on("connection", (rawSocket) => {
1271
+ registerRawSocketTimer(rawSocket);
1272
+ });
1273
+ srv.on("secureConnection", (tlsSocket) => {
1274
+ tlsSocket.setTimeout(0);
1275
+ const parentRaw = tlsSocket._parent;
1276
+ if (parentRaw) clearRawSocketTimer(parentRaw);
1277
+ else for (const [sock, pendingTimer] of handshakeTimers.entries()) if (sock.remotePort === tlsSocket.remotePort && sock.remoteAddress === tlsSocket.remoteAddress) {
1278
+ clearTimeout(pendingTimer);
1279
+ handshakeTimers.delete(sock);
1280
+ break;
1281
+ }
1282
+ if (isShuttingDown) {
1283
+ tlsSocket.destroy();
1284
+ return;
1285
+ }
1286
+ const pendingChunks = [];
1287
+ let pendingBytes = 0;
1288
+ let liveBridgeSock;
1289
+ if (needsLoopbackHttpBridge) tlsSocket.on("data", (chunk) => {
1290
+ const bytes = new Uint8Array(chunk);
1291
+ if (liveBridgeSock) {
1292
+ if (!liveBridgeSock.destroyed) liveBridgeSock.write(bytes);
1293
+ return;
1294
+ }
1295
+ pendingBytes += bytes.byteLength;
1296
+ if (pendingBytes > MAX_PRE_BRIDGE_BUFFER_BYTES) {
1297
+ pendingChunks.length = 0;
1298
+ tlsSocket.destroy();
1299
+ return;
1300
+ }
1301
+ pendingChunks.push(bytes);
1302
+ });
1303
+ else tlsSocket.pause();
1304
+ if (tlsSocket.getProtocol() !== "TLSv1.3" || tlsSocket.isSessionReused() === true) {
1305
+ pendingChunks.length = 0;
1306
+ logger.warn?.("[did-tls] rejected non-TLSv1.3 or resumed PSK/session-ticket connection", {
1307
+ protocol: tlsSocket.getProtocol(),
1308
+ sessionReused: tlsSocket.isSessionReused(),
1309
+ remoteAddress: tlsSocket.remoteAddress
1310
+ });
1311
+ tlsSocket.destroy();
1312
+ return;
1313
+ }
1314
+ let verifiedPeer;
1315
+ const peerCert = tlsSocket.getPeerCertificate(true);
1316
+ const peerPresentedCert = Boolean(peerCert && Object.keys(peerCert).length > 0);
1317
+ if (validatedTls.requireClientCert || peerPresentedCert) {
1318
+ const rawDer = peerCert && peerCert.raw instanceof Uint8Array && peerCert.raw.byteLength > 0 ? new Uint8Array(peerCert.raw.buffer, peerCert.raw.byteOffset, peerCert.raw.byteLength) : null;
1319
+ if (!rawDer) {
1320
+ pendingChunks.length = 0;
1321
+ tlsSocket.destroy();
1322
+ return;
1323
+ }
1324
+ const verdict = verifyDidTlsPeerCertificate(rawDer, {
1325
+ ...validatedTls.basePeerPolicy,
1326
+ now: clockNow()
1327
+ });
1328
+ if (!verdict.ok) {
1329
+ pendingChunks.length = 0;
1330
+ logger.warn?.("[did-tls] rejected unauthenticated TLS peer before HTTP/WS dispatch", {
1331
+ reason: verdict.reason,
1332
+ detail: verdict.detail,
1333
+ remoteAddress: tlsSocket.remoteAddress
1334
+ });
1335
+ tlsSocket.destroy();
1336
+ return;
1337
+ }
1338
+ verifiedPeer = verdict;
1339
+ tlsSocket.didTlsPeer = verdict;
1340
+ }
1341
+ activeTlsSockets.add(tlsSocket);
1342
+ tlsSocket.once("close", () => {
1343
+ activeTlsSockets.delete(tlsSocket);
1344
+ });
1345
+ tlsSocket.on("error", () => {
1346
+ tlsSocket.destroy();
1347
+ });
1348
+ if (!needsLoopbackHttpBridge) {
1349
+ server.emit("connection", tlsSocket);
1350
+ tlsSocket.resume();
1351
+ return;
1352
+ }
1353
+ if (internalHttpPort <= 0) {
1354
+ pendingChunks.length = 0;
1355
+ tlsSocket.destroy();
1356
+ return;
1357
+ }
1358
+ const bridgeSock = net.connect({
1359
+ host: "127.0.0.1",
1360
+ port: internalHttpPort
1361
+ });
1362
+ bridgeSockets.add(bridgeSock);
1363
+ let registeredPort;
1364
+ const entryObj = {
1365
+ bridgeSock,
1366
+ peer: verifiedPeer
1367
+ };
1368
+ const cleanupBridge = () => {
1369
+ bridgeSockets.delete(bridgeSock);
1370
+ if (registeredPort !== void 0) {
1371
+ const portKey = registeredPort;
1372
+ registeredPort = void 0;
1373
+ if (admittedBridgeByClientPort.get(portKey) === entryObj) admittedBridgeByClientPort.delete(portKey);
1374
+ }
1375
+ };
1376
+ bridgeSock.on("error", () => {
1377
+ cleanupBridge();
1378
+ tlsSocket.destroy();
1379
+ });
1380
+ bridgeSock.on("data", (chunk) => {
1381
+ if (!tlsSocket.destroyed) tlsSocket.write(new Uint8Array(chunk));
1382
+ });
1383
+ bridgeSock.once("close", () => {
1384
+ cleanupBridge();
1385
+ if (!tlsSocket.destroyed) tlsSocket.end();
1386
+ });
1387
+ tlsSocket.once("end", () => {
1388
+ if (!bridgeSock.destroyed) bridgeSock.end();
1389
+ });
1390
+ tlsSocket.once("close", () => {
1391
+ pendingChunks.length = 0;
1392
+ cleanupBridge();
1393
+ if (!bridgeSock.destroyed) bridgeSock.destroy();
1394
+ });
1395
+ bridgeSock.once("connect", () => {
1396
+ if (tlsSocket.destroyed || typeof bridgeSock.localPort !== "number" || bridgeSock.localPort <= 0) {
1397
+ pendingChunks.length = 0;
1398
+ cleanupBridge();
1399
+ bridgeSock.destroy();
1400
+ tlsSocket.destroy();
1401
+ return;
1402
+ }
1403
+ registeredPort = bridgeSock.localPort;
1404
+ admittedBridgeByClientPort.set(registeredPort, entryObj);
1405
+ liveBridgeSock = bridgeSock;
1406
+ for (const buffered of pendingChunks) bridgeSock.write(buffered);
1407
+ pendingChunks.length = 0;
1408
+ });
1409
+ });
1410
+ srv.on("tlsClientError", () => {});
1411
+ return srv;
1412
+ };
1413
+ const listenTlsLoopback = (srv) => new Promise((resolvePort, rejectPort) => {
1414
+ const onError = (err) => {
1415
+ srv.off("listening", onListening);
1416
+ rejectPort(err);
1417
+ };
1418
+ const onListening = () => {
1419
+ srv.off("error", onError);
1420
+ const addr = srv.address();
1421
+ resolvePort(addr && typeof addr === "object" ? addr.port : 0);
1422
+ };
1423
+ srv.once("error", onError);
1424
+ srv.once("listening", onListening);
1425
+ srv.listen(0, "127.0.0.1");
1426
+ });
1427
+ let activeTlsServer = createConfiguredTlsServer(initialMaterial.certPem, initialMaterial.keyPem);
1428
+ tlsServer = activeTlsServer;
1429
+ pushCleanup(async () => {
1430
+ isShuttingDown = true;
1431
+ await closeAllTlsNetworking();
1432
+ });
1433
+ if (needsLoopbackHttpBridge && !server.listening) await new Promise((resolveHttp, rejectHttp) => {
1434
+ const onError = (err) => {
1435
+ server.off("listening", onListening);
1436
+ rejectHttp(err);
1437
+ };
1438
+ const onListening = () => {
1439
+ server.off("error", onError);
1440
+ const bAddr = server.address();
1441
+ if (bAddr && typeof bAddr === "object") internalHttpPort = bAddr.port;
1442
+ resolveHttp();
1443
+ };
1444
+ server.once("error", onError);
1445
+ server.once("listening", onListening);
1446
+ server.listen(0, "127.0.0.1");
1447
+ });
1448
+ if (needsAtomicTlsSwap) {
1449
+ internalTlsPort = await listenTlsLoopback(activeTlsServer);
1450
+ const tcpListener = net.createServer((clientTcp) => {
1451
+ registerRawSocketTimer(clientTcp);
1452
+ if (isShuttingDown || internalTlsPort <= 0) {
1453
+ clientTcp.destroy();
1454
+ return;
1455
+ }
1456
+ const upstream = net.connect({
1457
+ host: "127.0.0.1",
1458
+ port: internalTlsPort
1459
+ });
1460
+ bridgeSockets.add(upstream);
1461
+ const earlyTcp = [];
1462
+ let earlyBytes = 0;
1463
+ let connected = false;
1464
+ clientTcp.on("data", (chunk) => {
1465
+ clearRawSocketTimer(clientTcp);
1466
+ const bytes = new Uint8Array(chunk);
1467
+ if (connected) {
1468
+ if (!upstream.destroyed) upstream.write(bytes);
1469
+ return;
1470
+ }
1471
+ earlyBytes += bytes.byteLength;
1472
+ if (earlyBytes > MAX_PRE_BRIDGE_BUFFER_BYTES) {
1473
+ earlyTcp.length = 0;
1474
+ clientTcp.destroy();
1475
+ upstream.destroy();
1476
+ return;
1477
+ }
1478
+ earlyTcp.push(bytes);
1479
+ });
1480
+ let upstreamBytesSent = 0;
1481
+ upstream.on("error", () => {
1482
+ bridgeSockets.delete(upstream);
1483
+ clientTcp.destroy();
1484
+ });
1485
+ upstream.on("data", (chunk) => {
1486
+ const bytes = new Uint8Array(chunk);
1487
+ upstreamBytesSent += bytes.byteLength;
1488
+ if (!clientTcp.destroyed) clientTcp.write(bytes);
1489
+ });
1490
+ upstream.once("close", () => {
1491
+ bridgeSockets.delete(upstream);
1492
+ if (!clientTcp.destroyed) if (upstreamBytesSent === 0) clientTcp.destroy();
1493
+ else clientTcp.end();
1494
+ });
1495
+ clientTcp.once("end", () => {
1496
+ if (!upstream.destroyed) upstream.end();
1497
+ });
1498
+ clientTcp.once("close", () => {
1499
+ earlyTcp.length = 0;
1500
+ bridgeSockets.delete(upstream);
1501
+ if (!upstream.destroyed) upstream.destroy();
1502
+ });
1503
+ upstream.once("connect", () => {
1504
+ if (clientTcp.destroyed) {
1505
+ bridgeSockets.delete(upstream);
1506
+ upstream.destroy();
1507
+ return;
1508
+ }
1509
+ connected = true;
1510
+ for (const c of earlyTcp) upstream.write(c);
1511
+ earlyTcp.length = 0;
1512
+ });
1513
+ });
1514
+ publicTcpServer = tcpListener;
1515
+ await new Promise((resolveListen, rejectListen) => {
1516
+ const onError = (err) => {
1517
+ tcpListener.off("listening", onListening);
1518
+ rejectListen(err);
1519
+ };
1520
+ const onListening = () => {
1521
+ tcpListener.off("error", onError);
1522
+ resolveListen();
1523
+ };
1524
+ tcpListener.once("error", onError);
1525
+ tcpListener.once("listening", onListening);
1526
+ tcpListener.listen(requestedPort, bindHost);
1527
+ });
1528
+ const tcpAddr = tcpListener.address();
1529
+ boundPort = tcpAddr && typeof tcpAddr === "object" && typeof tcpAddr.port === "number" ? tcpAddr.port : requestedPort;
1530
+ } else {
1531
+ await new Promise((resolveListen, rejectListen) => {
1532
+ const onError = (err) => {
1533
+ activeTlsServer.off("listening", onListening);
1534
+ rejectListen(err);
1535
+ };
1536
+ const onListening = () => {
1537
+ activeTlsServer.off("error", onError);
1538
+ resolveListen();
1539
+ };
1540
+ activeTlsServer.once("error", onError);
1541
+ activeTlsServer.once("listening", onListening);
1542
+ activeTlsServer.listen(requestedPort, bindHost);
1543
+ });
1544
+ const tlsAddr = activeTlsServer.address();
1545
+ boundPort = tlsAddr && typeof tlsAddr === "object" && typeof tlsAddr.port === "number" ? tlsAddr.port : requestedPort;
1546
+ }
1547
+ reloadTlsCredentials = async () => {
1548
+ const refreshed = loadOrSynthesizeTlsMaterial();
1549
+ if (needsAtomicTlsSwap && activeTlsServer.listening) {
1550
+ const nextTlsServer = createConfiguredTlsServer(refreshed.certPem, refreshed.keyPem);
1551
+ const nextPort = await listenTlsLoopback(nextTlsServer);
1552
+ const previousTlsServer = activeTlsServer;
1553
+ activeTlsServer = nextTlsServer;
1554
+ tlsServer = nextTlsServer;
1555
+ internalTlsPort = nextPort;
1556
+ retiredTlsServers.add(previousTlsServer);
1557
+ previousTlsServer.close(() => {
1558
+ retiredTlsServers.delete(previousTlsServer);
1559
+ });
1560
+ } else activeTlsServer.setSecureContext(buildChainTlsSecureContextOptions(refreshed.certPem, refreshed.keyPem));
1561
+ return {
1562
+ reloaded: true,
1563
+ subjectDid: refreshed.subjectDid,
1564
+ spkiSha256Hex: refreshed.spkiSha256Hex
1565
+ };
1566
+ };
1567
+ } else {
1568
+ await new Promise((resolveListen, rejectListen) => {
1569
+ const onError = (err) => {
1570
+ server.off("listening", onListening);
1571
+ rejectListen(err);
1572
+ };
1573
+ const onListening = () => {
1574
+ server.off("error", onError);
1575
+ resolveListen();
1576
+ };
1577
+ server.once("error", onError);
1578
+ server.once("listening", onListening);
1579
+ server.listen(requestedPort, bindHost);
1580
+ });
1581
+ const addressInfo = server.address();
1582
+ boundPort = addressInfo && typeof addressInfo === "object" && typeof addressInfo.port === "number" ? addressInfo.port : requestedPort;
1583
+ }
873
1584
  const urlHost = formatHttpHostForUrl(bindHost);
874
- const endpoint = `http://${urlHost}:${boundPort}`;
875
- const wsUrl = `ws://${urlHost}:${boundPort}`;
1585
+ const endpoint = `${validatedTls ? "https" : "http"}://${urlHost}:${boundPort}`;
1586
+ const wsUrl = `${validatedTls ? "wss" : "ws"}://${urlHost}:${boundPort}`;
876
1587
  if (testHooks?.onAfterBoot) await testHooks.onAfterBoot({
877
1588
  dataDir,
878
1589
  statedb,
@@ -913,7 +1624,8 @@ async function bootChainNodeOnce(params) {
913
1624
  isShuttingDown = true;
914
1625
  server.closeIdleConnections?.();
915
1626
  await waitForActiveHttpDrain();
916
- await new Promise((resolveClose) => {
1627
+ if (validatedTls) await closeAllTlsNetworking();
1628
+ else await new Promise((resolveClose) => {
917
1629
  server.close(() => resolveClose());
918
1630
  });
919
1631
  await resolver.shutdown().catch(captureErr);
@@ -977,10 +1689,14 @@ async function bootChainNodeOnce(params) {
977
1689
  indexdb,
978
1690
  trustedStorage,
979
1691
  server,
1692
+ get tlsServer() {
1693
+ return tlsServer;
1694
+ },
980
1695
  ...followerSync ? { followerSync } : {},
981
1696
  ...hotstuffRuntime ? { hotstuffRuntime } : {},
982
1697
  preferencesManager,
983
1698
  maintenanceController,
1699
+ reloadTlsCredentials,
984
1700
  stop
985
1701
  };
986
1702
  } catch (err) {
@@ -1077,6 +1793,9 @@ async function startChainNode(optionsOrProfile) {
1077
1793
  get server() {
1078
1794
  return currentBooted.server;
1079
1795
  },
1796
+ get tlsServer() {
1797
+ return currentBooted.tlsServer;
1798
+ },
1080
1799
  get followerSync() {
1081
1800
  return currentBooted.followerSync;
1082
1801
  },
@@ -1092,15 +1811,23 @@ async function startChainNode(optionsOrProfile) {
1092
1811
  async ledgerHealth() {
1093
1812
  return currentBooted.ledger.getHealth();
1094
1813
  },
1814
+ async reloadTlsCredentials() {
1815
+ return withLifecycleLock(async () => currentBooted.reloadTlsCredentials());
1816
+ },
1095
1817
  ...advanceClockFn ? { advanceClock: advanceClockFn } : {},
1096
1818
  async restart(nextProfile) {
1097
1819
  return withLifecycleLock(async () => {
1098
1820
  const previousPort = currentBooted.port;
1099
1821
  await currentBooted.stop();
1822
+ const mergedTls = nextProfile?.http && "tls" in nextProfile.http ? nextProfile.http.tls ? {
1823
+ ...currentProfile.http.tls ?? {},
1824
+ ...nextProfile.http.tls
1825
+ } : void 0 : currentProfile.http.tls;
1100
1826
  const mergedHttp = {
1101
1827
  ...currentProfile.http,
1102
1828
  ...nextProfile?.http ?? {},
1103
- port: nextProfile?.http?.port !== void 0 ? nextProfile.http.port : previousPort
1829
+ port: nextProfile?.http?.port !== void 0 ? nextProfile.http.port : previousPort,
1830
+ ...mergedTls !== void 0 ? { tls: mergedTls } : { tls: void 0 }
1104
1831
  };
1105
1832
  const mergedProfile = {
1106
1833
  ...currentProfile,
@@ -1150,4 +1877,4 @@ async function startChainNode(optionsOrProfile) {
1150
1877
  }
1151
1878
 
1152
1879
  //#endregion
1153
- export { startChainNode };
1880
+ export { startChainNode, writeFileDurably };