socketduct 0.1.19 → 0.1.21

package/test/unit/reverse/disconnect-attribution.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict"
+import {createHmac} from "node:crypto"
+import test from "node:test"
+
+import {
+  attachDisconnectAttribution,
+  connectionFingerprint,
+  createDisconnectAttribution,
+  parseDisconnectAttribution,
+  sanitizePeerControlDetail
+} from "../../../src/reverse/disconnect-attribution.js"
+
+test("disconnect attribution uses one bounded incident and named generations", () => {
+  const attribution = createDisconnectAttribution({
+    disconnectReason: "remote_socket_error",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    clientConnectionGeneration: 17,
+    gatewayConnectionGeneration: 23,
+    fanOutCount: 5,
+    resumeSuccessCount: 2,
+    terminalStreamCount: 1
+  })
+
+  assert.match(attribution.disconnectIncidentId, /^[A-Za-z0-9_-]{22}$/)
+  assert.deepEqual(parseDisconnectAttribution(attribution), attribution)
+  assert.equal("generation" in attribution, false)
+
+  const error = /** @type {Error & Record<string, unknown>} */ (attachDisconnectAttribution(Object.assign(new Error("classified terminal"), {code: "GATEWAY_DISCONNECTED"}), attribution))
+  assert.equal(error.code, "GATEWAY_DISCONNECTED")
+  assert.equal(error.disconnectReason, "remote_socket_error")
+  assert.equal(error.disconnectIncidentId, attribution.disconnectIncidentId)
+  assert.equal(error.gatewayConnectionGeneration, 23)
+})
+
+test("peer control detail cannot assert hub-owned disconnect fields", () => {
+  const result = sanitizePeerControlDetail({
+    code: "TARGET_CLOSED",
+    disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
+    disconnectReason: "hub_shutdown",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    gatewayConnectionGeneration: 9,
+    fanOutCount: 4,
+    target: "docker.internal:2375",
+    token: "secret"
+  })
+
+  assert.deepEqual(result.detail, {code: "TARGET_CLOSED"})
+  assert.equal(result.reservedFieldsStripped, 6)
+})
+
+test("hub connection fingerprints are keyed, role-separated, and truncated to 128 bits", () => {
+  const key = Buffer.alloc(32, 0x5a)
+  const connectionId = "low_entropy_connection_01"
+  const expected = createHmac("sha256", key)
+    .update("socketduct-connection-id:v1")
+    .update(Buffer.from([0]))
+    .update("gateway")
+    .update(Buffer.from([0]))
+    .update(connectionId)
+    .digest()
+    .subarray(0, 16)
+    .toString("hex")
+
+  const actual = connectionFingerprint(key, "gateway", connectionId)
+  assert.equal(actual, expected)
+  assert.match(actual, /^[a-f0-9]{32}$/)
+  assert.notEqual(actual, connectionId)
+  assert.notEqual(actual, connectionFingerprint(key, "client", connectionId))
+  assert.throws(() => connectionFingerprint(Buffer.alloc(31), "gateway", connectionId), /at least 32 bytes/)
+})
+
+test("malformed attribution is rejected instead of partially trusted", () => {
+  assert.equal(parseDisconnectAttribution({
+    disconnectIncidentId: "AAAAAAAAAAAAAAAAAAAAAA",
+    disconnectReason: "not-a-reason",
+    incidentOrigin: "reverse_hub",
+    physicalRole: "gateway",
+    gatewayConnectionGeneration: 1
+  }), undefined)
+})

package/test/unit/spool/spool-file.test.js

@@ -63,6 +63,64 @@ test("SessionSpool truncates acknowledged chunks", async () => {
   })
 })
 
+test("SessionSpool truncates an acknowledgement inside a chunk in application bytes", async () => {
+  await withTempDir(async (root) => {
+    const spool = new SessionSpool({rootDir: root})
+    const sessionId = "session_partial_ack"
+    await spool.create({sessionId, ownerId: "user-1"})
+    await spool.appendChunk({sessionId, sequence: 8, data: Buffer.from("abcdefgh")})
+
+    await spool.truncateAcked(sessionId, 3)
+
+    const chunks = await spool.readChunksAfter(sessionId, 3)
+    assert.deepEqual(chunks, [{sequence: 8, data: Buffer.from("defgh")}])
+    assert.equal(spool.getUsedBytes(sessionId), 5)
+  })
+})
+
+test("SessionSpool atomically admits a complete chunk batch before recovery commit", async () => {
+  await withTempDir(async (root) => {
+    const spool = new SessionSpool({rootDir: root, maxBytes: 32})
+    const sessionId = "session_durable_batch"
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 4, data: Buffer.from("base")})
+    await spool.writeRecoveryState(sessionId, {version: 3, sendSequence: 4})
+
+    await spool.appendChunksAndRecoveryState({
+      sessionId,
+      ownerId: "reverse-client-v3",
+      previousSequence: 4,
+      chunks: [
+        {sequence: 7, data: Buffer.from("one")},
+        {sequence: 10, data: Buffer.from("two")}
+      ],
+      recoveryState: {version: 3, sendSequence: 10}
+    })
+
+    assert.deepEqual((await spool.readChunksAfter(sessionId, 0)).map(({sequence, data}) => [sequence, data.toString()]), [
+      [4, "base"],
+      [7, "one"],
+      [10, "two"]
+    ])
+    assert.deepEqual(spool.readRecoveryStateSync(sessionId, "reverse-client-v3"), {version: 3, sendSequence: 10})
+    assert.equal(spool.getUsedBytes(sessionId), 10)
+  })
+})
+
+test("SessionSpool recovery lookup distinguishes missing state from invalid state", async () => {
+  await withTempDir(async (root) => {
+    const spool = new SessionSpool({rootDir: root})
+    assert.equal(spool.findRecoveryStateSync("missing_session", "edge-v3"), undefined)
+
+    await spool.createNew({sessionId: "present_session", ownerId: "edge-v3"})
+    await spool.writeRecoveryState("present_session", {version: 3})
+    assert.deepEqual(spool.findRecoveryStateSync("present_session", "edge-v3"), {version: 3})
+
+    await writeFile(join(root, "present_session", "recovery.json"), "{invalid\n")
+    assert.throws(() => spool.findRecoveryStateSync("present_session", "edge-v3"), /Invalid Socketduct recovery state/)
+  })
+})
+
 test("SessionSpool rejects path traversal and mismatched metadata", async () => {
   await withTempDir(async (root) => {
     const spool = new SessionSpool({rootDir: root})