@steve02081504/fount-p2p 0.0.42 → 0.0.43

package/AGENTS.md

@@ -35,6 +35,7 @@ Deno / native / BT: [runtime.md](docs/runtime.md).
 - **Heterogeneous backends:** normalize at the load boundary (e.g. `link/rtc/ice_local_hostname.mjs` wraps W3C RTC backends); call sites speak one contract.
 - **File naming:** parent directory is scope — short child names. Tunables default `<dir>/tunables.json` (exception: `schemas/part_query.tunables.json`). Subpath `package.json` exports mirror filenames.
 - **Import boundary:** `test/integration/p2p_shell_import_guard.test.mjs`.
+- **Security fixes are not backward compatible:** fount guarantees the whole network upgrades to the latest build together. Fix wire formats directly — no version fields, no compat branches.
 - **No scattered `trim` / `toLowerCase`:** hex IDs must already be lowercase and without a `0x` prefix — a `0x`-prefixed, mixed-case, or whitespace value is rejected by `isHex64`/`isEntityHash128`, never cleaned. Exceptions: JSONL blank lines, SDP fingerprint, CLI/`scripts` parsing.
 - **No `String(x)` / `x || ''` on typed `string`:** if `@param {string}`, use it directly; `String(...)` / `|| ''` / `?? ''` only at optional / `unknown` / disk / inbound boundaries, or number→string.
 - **Optional methods:** `if (fn) return await fn(...)` / `if (fn) …` — never `typeof x === 'function'`.

package/discovery/lan_interfaces.mjs

@@ -3,12 +3,29 @@ import os from 'node:os'
 /** advert / 组播 beacon 携带的 LAN IPv4 上限 */
 export const MAX_LAN_HOSTS = 4
 
-const IPV4_RE = /^(?:\d{1,3}\.){3}\d{1,3}$/
+/**
+ * 私网 / 链路本地 IPv4（RFC1918 + 169.254/16）。
+ * advert 自报地址只允许这些：否则攻击者可借受害者的拨号对内网/公网发起 TCP 探测（SSRF）。
+ * @param {string} host 候选 IPv4
+ * @returns {boolean} 是否允许作为可拨号 LAN hint
+ */
+function isPrivateLanIpv4(host) {
+	const parts = host.split('.')
+	if (parts.length !== 4) return false
+	const octets = parts.map(part => Number(part))
+	if (octets.some(n => !Number.isInteger(n) || n < 0 || n > 255)) return false
+	const [a, b] = octets
+	if (a === 10) return true
+	if (a === 172 && b >= 16 && b <= 31) return true
+	if (a === 192 && b === 168) return true
+	if (a === 169 && b === 254) return true
+	return false
+}
 
 /**
  * untrusted ingress：清洗 advert body 中的 LAN IPv4 列表。
  * @param {unknown} input 原始 lanHosts
- * @returns {string[]} 去重后的 IPv4 列表
+ * @returns {string[]} 去重后的私网/链路本地 IPv4 列表
  */
 export function normalizeLanHosts(input) {
 	if (!input) return []
@@ -18,7 +35,7 @@ export function normalizeLanHosts(input) {
 	const out = []
 	for (const item of arr) {
 		const host = String(item || '')
-		if (!host || !IPV4_RE.test(host) || seen.has(host)) continue
+		if (!host || !isPrivateLanIpv4(host) || seen.has(host)) continue
 		seen.add(host)
 		out.push(host)
 		if (out.length >= MAX_LAN_HOSTS) break

package/docs/evfs.md

@@ -45,6 +45,7 @@ Outer caller timeouts must **not** abort the in-flight work — background fill
 - `fetchChunk` accepts the same `fanoutTargets` as `fetchManifest`. With targets it fanouts `fed_chunk_get` **only** to that node set; without targets it falls back to node-scope fanout. Same `username`+chunk hash+mode (`targeted`/`public`) is deduped in-flight.
 - `readPublicFile` / `readManifestPlaintext` forward `options.fanoutTargets` to both the manifest fetch and the chunk fetch, so a cross-node public read can pull profile/avatar content straight from the owner node instead of depending on the node-scope fanout.
 - The public (non-targeted) fanout does **not** block the request window on dialing the whole peer pool: already-linked / group-room-reachable peers are sent immediately, and unreachable peers are dialed in the background and re-sent once linked. (`ensureLinkToNode` no longer gates the send.)
+- **Chunk serving is by-design unauthenticated CAS:** `fed_chunk_get` returns a chunk iff the requester already knows its 64-hex content hash (which is infeasible to enumerate), and `verifiedChunkBytes` re-checks that hash on receipt. There is no per-requester ACL. Confidentiality therefore rests on the manifest being ACL-gated and on encryption: `convergent` / `random` chunks are ciphertext, while `plain` chunks are plaintext — non-public files must not use `plain`.
 
 ## Non-public (ACL-gated) manifests
 

package/docs/transports.md

@@ -6,6 +6,10 @@ Mesh keep-alive / discovery: [mesh.md](mesh.md). WebRTC glare / handshake: [sign
 
 Do **not** introduce version fields, constants, or suffixes (`v`, `version`, `FRAME_VERSION`, `:v1`, …). Changing a shape means changing it; no dual-read / backward-compat paths. Exception: npm `package.json` `version` is for package publish only.
 
+## Overlay relay authenticity
+
+`overlay/index.mjs` multi-hop relay carries an origin signature: `relay()` signs `(path, body)` with the origin key, intermediate hops forward `nodePubKey`/`sig` untouched, and the terminal node verifies `pubKeyHash(nodePubKey) === path[0]` before treating the body as sent by that node. Unsigned or forged relays are dropped. `route_resp` is only accepted when the signed path's last hop equals the discovery target. Overlay `route_req`/`relay` are token-bucket limited by default (`overlay/tunables.json`, 120/min burst 30); `startInfra` may override the gate.
+
 ## Public contract (shell / L4)
 
 This package exposes a **fount network**: talk to `nodeHash` peers with envelopes.

package/docs/wire.md

@@ -14,6 +14,12 @@ Day-to-day trust rules: [AGENTS.md](../AGENTS.md). Node-scope presets: [infra.md
 
 Part query runtime lives under `federation/part_query/*`; wire attach only in `wire/part/query.mjs`.
 
+## Part query response signing / source attribution
+
+- Every `part_query_res` is self-signed by the responding node: `parsePartQueryRes` requires `nodePubKey` (64 hex) + `sig` (128 hex), and the runtime verifies `pubKeyHash(nodePubKey) === fromNodeHash` plus the signature over `(requestId, fromNodeHash, rows)` before accepting. Invalid responses are dropped, so a neighbor cannot forge a result or attribute it to another node.
+- `queryNetwork` returns `{ rows, sources }` (not a bare array), where `sources` is a `Map<rowKey, string[]>` of contributing responder nodeHashes. Cached entries keep the same provenance.
+- `options.isSourceBlocked(nodeHash)` filters rows whose source set is non-empty and entirely blocked. Shells wire this to their source-block UI; local rows have an empty source set and are never filtered here.
+
 ## Timed collect
 
 APIs with `timeoutMs` (e.g. `collectPartInvokeResponses`) must register the wait **first** and must **not** `await` fanout/send on the return path — a stuck `discoverRoute` / `link.send` otherwise defeats the timeout.

package/federation/part_query/cache.mjs

@@ -4,7 +4,7 @@ import partQueryTunables from '../../schemas/part_query.tunables.json' with { ty
 import { createLruMap } from '../../utils/lru.mjs'
 
 /**
- * @typedef {{ rows: unknown[], storedAt: number }} PartQueryCacheEntry
+ * @typedef {{ rows: unknown[], storedAt: number, sources: Map<string, Set<string>> }} PartQueryCacheEntry
  */
 
 /**
@@ -24,7 +24,8 @@ export function partQueryCacheKey(partpath, kind, query) {
  * @param {{ maxKeys?: number, ttlMs?: number, maxHits?: number }} [options] 容量 / TTL / 单键 rows 上限
  * @returns {{
  *   get: (partpath: string, kind: string, query: unknown, now?: number) => unknown[] | null
- *   set: (partpath: string, kind: string, query: unknown, rows: unknown[], now?: number) => void
+ *   getWithSources: (partpath: string, kind: string, query: unknown, now?: number) => { rows: unknown[], sources: Map<string, Set<string>> } | null
+ *   set: (partpath: string, kind: string, query: unknown, rows: unknown[], now?: number, sources?: Map<string, Set<string>>) => void
  *   clear: () => void
  *   readonly size: number
  * }} 缓存 API
@@ -54,6 +55,18 @@ export function createPartQueryCache(options = {}) {
 		 * @returns {unknown[] | null} 未过期 rows
 		 */
 		get(partpath, kind, query, now = Date.now()) {
+			const entry = this.getWithSources(partpath, kind, query, now)
+			return entry ? entry.rows : null
+		},
+
+		/**
+		 * @param {string} partpath part 路径
+		 * @param {string} kind 查询标签
+		 * @param {unknown} query 查询体
+		 * @param {number} [now=Date.now()] 当前时间
+		 * @returns {{ rows: unknown[], sources: Map<string, Set<string>> } | null} 未过期 rows 与来源
+		 */
+		getWithSources(partpath, kind, query, now = Date.now()) {
 			const key = partQueryCacheKey(partpath, kind, query)
 			if (!key) return null
 			const entry = map.get(key)
@@ -63,7 +76,7 @@ export function createPartQueryCache(options = {}) {
 				return null
 			}
 			map.touch(key, entry)
-			return entry.rows.slice()
+			return { rows: entry.rows.slice(), sources: entry.sources }
 		},
 
 		/**
@@ -72,9 +85,10 @@ export function createPartQueryCache(options = {}) {
 		 * @param {unknown} query 查询体
 		 * @param {unknown[]} rows 聚合 rows（空数组不入库）
 		 * @param {number} [now=Date.now()] 当前时间
+		 * @param {Map<string, Set<string>>} [sources] rowKey→来源集合
 		 * @returns {void}
 		 */
-		set(partpath, kind, query, rows, now = Date.now()) {
+		set(partpath, kind, query, rows, now = Date.now(), sources = null) {
 			const key = partQueryCacheKey(partpath, kind, query)
 			// 空 miss 不缓存：mesh 晚就绪 / 超时早查询不应被长 TTL 负缓存粘住
 			if (!key || !Array.isArray(rows) || rows.length === 0) return
@@ -82,6 +96,7 @@ export function createPartQueryCache(options = {}) {
 			map.touch(key, {
 				rows: rows.slice(0, maxHits),
 				storedAt: now,
+				sources: sources || new Map(),
 			})
 		},
 

package/federation/part_query/runtime.mjs

@@ -1,7 +1,10 @@
+import { Buffer } from 'node:buffer'
 import { randomUUID } from 'node:crypto'
 
+import { canonicalStringify } from '../../core/canonical_json.mjs'
 import { compositeKey } from '../../core/composite_key.mjs'
-import { getNodeHash } from '../../node/identity.mjs'
+import { keyPairFromSeed, pubKeyHash, sign, verify } from '../../crypto/crypto.mjs'
+import { ensureNodeSeed, getNodeHash } from '../../node/identity.mjs'
 import { loadReputation } from '../../node/reputation_store.mjs'
 import { isQuarantinedPure } from '../../reputation/engine.mjs'
 import {
@@ -23,6 +26,55 @@ import { createPartQueryCache, partQueryCache } from './cache.mjs'
 
 /** @typedef {import('../../wire/adapter.mjs').WireAdapter} PartQueryWire */
 
+const PART_QUERY_DOMAIN = 'fount-part-query'
+
+/**
+ * 构造 part_query_res 签名材料：仅覆盖 (requestId, fromNodeHash, rows)。
+ * 来源节点借此自证，中间节点无法篡改结果或来源。
+ * @param {{ requestId: string, fromNodeHash: string, rows: unknown[] }} base 响应基体
+ * @returns {Uint8Array} 待签名字节
+ */
+function partQuerySignBytes(base) {
+	return Buffer.from(`${PART_QUERY_DOMAIN}\0${base.requestId}\0${base.fromNodeHash}\0${canonicalStringify(base.rows)}`, 'utf8')
+}
+
+/**
+ * 默认响应签名：用本机节点身份签响应基体。
+ * @param {{ requestId: string, fromNodeHash: string, rows: unknown[] }} base 响应基体
+ * @returns {Promise<{ nodePubKey: string, sig: string }>} 公钥与签名
+ */
+async function defaultSignResponse(base) {
+	const { publicKey, secretKey } = keyPairFromSeed(Buffer.from(ensureNodeSeed(), 'hex'))
+	const signature = await sign(partQuerySignBytes(base), secretKey)
+	return { nodePubKey: Buffer.from(publicKey).toString('hex'), sig: Buffer.from(signature).toString('hex') }
+}
+
+/**
+ * 默认响应验签：nodePubKey 哈希须等于 fromNodeHash，且签名覆盖响应基体。
+ * @param {{ requestId: string, fromNodeHash: string, rows: unknown[], nodePubKey: string, sig: string }} response 响应
+ * @returns {Promise<boolean>} 是否可信
+ */
+async function defaultVerifyResponse(response) {
+	if (pubKeyHash(Buffer.from(response.nodePubKey, 'hex')) !== response.fromNodeHash) return false
+	return await verify(Buffer.from(response.sig, 'hex'), partQuerySignBytes(response), Buffer.from(response.nodePubKey, 'hex'))
+}
+
+/**
+ * @param {PartQueryDependencies} dependencies 依赖
+ * @returns {(base: { requestId: string, fromNodeHash: string, rows: unknown[] }) => Promise<{ nodePubKey: string, sig: string }>} 签名函数
+ */
+function responseSigner(dependencies) {
+	return dependencies.signResponse || defaultSignResponse
+}
+
+/**
+ * @param {PartQueryDependencies} dependencies 依赖
+ * @returns {(response: { requestId: string, fromNodeHash: string, rows: unknown[], nodePubKey: string, sig: string }) => Promise<boolean>} 验签函数
+ */
+function responseVerifier(dependencies) {
+	return dependencies.verifyResponse || defaultVerifyResponse
+}
+
 /**
  * @typedef {{
  *   replicaUsername?: string
@@ -40,18 +92,24 @@ import { createPartQueryCache, partQueryCache } from './cache.mjs'
  *   takeDedupe: (key: string) => boolean
  *   relayPending: Map<string, RelayPending>
  *   originWaits: Map<string, Map<string, import('../../wire/wait.mjs').WireWaiter[]>>
- *   originBags: Map<string, { rows: unknown[], maxHits: number, expected: number, received: number, respondedPeers: Set<string>, rowKey?: (row: unknown) => string }>
+ *   originBags: Map<string, { entries: Array<{ rows: unknown[], sourceNodeHash?: string }>, maxHits: number, expected: number, received: number, respondedPeers: Set<string>, rowKey?: (row: unknown) => string }>
  *   cache: ReturnType<typeof createPartQueryCache>
  *   handlers: Map<string, QueryInboundHandler>
  * }} PartQueryNodeState
  */
 
+/**
+ * @typedef {{ rows: unknown[], sourceNodeHash?: string }} QueryRowEntry
+ */
+
 /**
  * @typedef {{
  *   selectNeighbors?: (exclude: Set<string>) => Promise<string[]>
  *   deliver?: (nodeHash: string, action: string, payload: unknown) => Promise<boolean> | boolean
  *   getNodeHash?: () => string
  *   now?: () => number
+ *   signResponse?: (base: { requestId: string, fromNodeHash: string, rows: unknown[] }) => Promise<{ nodePubKey: string, sig: string }>
+ *   verifyResponse?: (response: { requestId: string, fromNodeHash: string, rows: unknown[], nodePubKey: string, sig: string }) => Promise<boolean>
  *   state?: PartQueryNodeState
  * }} PartQueryDependencies
  */
@@ -62,7 +120,7 @@ import { createPartQueryCache, partQueryCache } from './cache.mjs'
  *   wire: PartQueryWire
  *   request: PartQueryReq
  *   localRows: unknown[]
- *   remoteRows: unknown[]
+ *   remoteEntries: QueryRowEntry[]
  *   expected: number
  *   received: number
  *   respondedPeers: Set<string>
@@ -152,6 +210,40 @@ export function mergeQueryRows(lists, maxHits, rowKey) {
 	return out
 }
 
+/**
+ * 合并带来源的 rows，并记录每个去重行键的来源节点集合。
+ * 本地行 `sourceNodeHash` 省略（不可被屏蔽）。
+ * @param {QueryRowEntry[]} entries 多路 rows（含来源）
+ * @param {number} maxHits 上限
+ * @param {(row: unknown) => string} [rowKey] 去重键
+ * @returns {{ rows: unknown[], sources: Map<string, Set<string>> }} 合并结果与 rowKey→来源集合
+ */
+function mergeRowsWithSources(entries, maxHits, rowKey) {
+	const rows = []
+	const seen = new Set()
+	/** @type {Map<string, Set<string>>} */
+	const sources = new Map()
+	const keyOf = rowKey || (row => {
+		try { return JSON.stringify(row) }
+		catch { return `\0${rows.length}` }
+	})
+	for (const entry of entries) {
+		for (const row of entry.rows || []) {
+			const key = keyOf(row)
+			if (!seen.has(key)) {
+				seen.add(key)
+				rows.push(row)
+				sources.set(key, new Set())
+				if (entry.sourceNodeHash) sources.get(key).add(entry.sourceNodeHash)
+				if (rows.length >= maxHits) return { rows, sources }
+				continue
+			}
+			if (entry.sourceNodeHash) sources.get(key).add(entry.sourceNodeHash)
+		}
+	}
+	return { rows, sources }
+}
+
 /**
  * @param {PartQueryNodeState} state 节点状态
  * @param {QueryInboundContext} queryContext 入站上下文
@@ -206,20 +298,59 @@ async function deliverQuery(nodeHash, action, payload, dependencies) {
  * @param {() => string} nodeHashOf 本机 hash
  * @returns {PartQueryRes} 响应载荷
  */
-function buildResponse(request, rows, nodeHashOf) {
+/**
+ * @param {PartQueryReq} request 请求
+ * @param {unknown[]} rows 行
+ * @param {() => string} nodeHashOf 本机 hash
+ * @param {PartQueryDependencies} dependencies 依赖
+ * @returns {Promise<PartQueryRes>} 已签名的响应
+ */
+async function buildResponse(request, rows, nodeHashOf, dependencies) {
 	const capped = clampPartQueryRows(rows, request.budget.maxHits) || []
-	return {
-		requestId: request.requestId,
-		fromNodeHash: nodeHashOf(),
-		rows: capped,
-	}
+	const base = { requestId: request.requestId, fromNodeHash: nodeHashOf(), rows: capped }
+	const { nodePubKey, sig } = await responseSigner(dependencies)(base)
+	return { ...base, nodePubKey, sig }
+}
+
+/**
+ * 按来源屏蔽表过滤 rows：来源集合非空且全部被屏蔽时剔除该行。
+ * @param {unknown[]} rows 行
+ * @param {Map<string, Set<string>>} sources rowKey→来源集合
+ * @param {(row: unknown) => string} [rowKey] 去重键
+ * @param {((nodeHash: string) => boolean) | undefined} isSourceBlocked 来源屏蔽谓词
+ * @returns {unknown[]} 过滤后的 rows
+ */
+function filterRowsBySource(rows, sources, rowKey, isSourceBlocked) {
+	if (typeof isSourceBlocked !== 'function') return rows
+	return rows.filter(row => {
+		let key
+		if (rowKey) key = rowKey(row)
+		else {
+			try { key = JSON.stringify(row) }
+			catch { return true }
+		}
+		const set = sources.get(key)
+		if (!set || set.size === 0) return true
+		for (const source of set) if (!isSourceBlocked(source)) return true
+		return false
+	})
+}
+
+/**
+ * @param {Map<string, Set<string>>} sources rowKey→来源集合
+ * @returns {Map<string, string[]>} rowKey→来源数组
+ */
+function sourcesToArrays(sources) {
+	const out = new Map()
+	for (const [key, set] of sources) out.set(key, [...set])
+	return out
 }
 
 /**
  * @param {RelayPending} pending 中继槽
- * @returns {void}
+ * @returns {Promise<void>}
  */
-function flushRelayPending(pending) {
+async function flushRelayPending(pending) {
 	if (pending.flushed) return
 	pending.flushed = true
 	if (pending.timer) {
@@ -227,12 +358,15 @@ function flushRelayPending(pending) {
 		pending.timer = null
 	}
 	pending.state.relayPending.delete(pending.request.requestId)
-	const merged = mergeQueryRows([pending.localRows, pending.remoteRows], pending.request.budget.maxHits)
+	const merged = mergeRowsWithSources(
+		[{ rows: pending.localRows }, ...pending.remoteEntries],
+		pending.request.budget.maxHits,
+	)
 	const now = pending.dependencies.now || Date.now
-	pending.state.cache.set(pending.request.partpath, pending.request.kind, pending.request.query, merged, now())
+	pending.state.cache.set(pending.request.partpath, pending.request.kind, pending.request.query, merged.rows, now(), merged.sources)
 	const nodeHashOf = pending.dependencies.getNodeHash || getNodeHash
 	try {
-		pending.wire.send('part_query_res', buildResponse(pending.request, merged, nodeHashOf), pending.upstreamPeerId)
+		pending.wire.send('part_query_res', await buildResponse(pending.request, merged.rows, nodeHashOf, pending.dependencies), pending.upstreamPeerId)
 	}
 	catch { /* disconnected */ }
 }
@@ -251,9 +385,9 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
 	const now = dependencies.now || Date.now
 	const username = wireContext.replicaUsername || ''
 
-	const cached = state.cache.get(request.partpath, request.kind, request.query, now())
+	const cached = state.cache.getWithSources(request.partpath, request.kind, request.query, now())
 	if (cached) {
-		try { wire.send('part_query_res', buildResponse(request, cached, nodeHashOf), peerId) }
+		try { wire.send('part_query_res', await buildResponse(request, cached.rows, nodeHashOf, dependencies), peerId) }
 		catch { /* disconnected */ }
 		return
 	}
@@ -266,8 +400,8 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
 
 	const nextTtl = request.ttl - 1
 	if (nextTtl <= 0) {
-		state.cache.set(request.partpath, request.kind, request.query, localRows, now())
-		try { wire.send('part_query_res', buildResponse(request, localRows, nodeHashOf), peerId) }
+		state.cache.set(request.partpath, request.kind, request.query, localRows, now(), new Map())
+		try { wire.send('part_query_res', await buildResponse(request, localRows, nodeHashOf, dependencies), peerId) }
 		catch { /* disconnected */ }
 		return
 	}
@@ -282,7 +416,7 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
 		wire,
 		request,
 		localRows,
-		remoteRows: [],
+		remoteEntries: [],
 		expected: 0,
 		received: 0,
 		respondedPeers: new Set(),
@@ -293,7 +427,7 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
 	}
 	state.relayPending.set(request.requestId, pending)
 	// 先挂 hop 超时：勿等 select/deliver settle，否则 stuck send 永不 flush upstream（#13 同类）
-	pending.timer = setTimeout(() => flushRelayPending(pending), resolvePartQueryHopTimeoutMs(request.ttl))
+	pending.timer = setTimeout(() => { void flushRelayPending(pending) }, resolvePartQueryHopTimeoutMs(request.ttl))
 
 	void (async () => {
 		try {
@@ -305,10 +439,10 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
 			if (pending.flushed) return
 			pending.expected = sent
 			if (sent === 0 || pending.received >= pending.expected)
-				flushRelayPending(pending)
+				void flushRelayPending(pending)
 		}
 		catch {
-			if (!pending.flushed) flushRelayPending(pending)
+			if (!pending.flushed) void flushRelayPending(pending)
 		}
 	})()
 }
@@ -319,28 +453,26 @@ export async function processIncomingPartQueryRequest(wireContext, wire, request
  * @param {PartQueryDependencies} [dependencies] 依赖
  * @returns {void}
  */
-export function handleIncomingPartQueryResponse(response, peerId = '', dependencies = {}) {
+export async function handleIncomingPartQueryResponse(response, peerId = '', dependencies = {}) {
 	const state = resolvePartQueryState(dependencies)
-	const responderKey = peerId || response.fromNodeHash
+	// 响应必须自证来源；验签失败直接丢弃，避免任意邻居伪造/投毒结果与缓存。
+	if (!await responseVerifier(dependencies)(response)) return
+	const responderKey = response.fromNodeHash
 	const relay = state.relayPending.get(response.requestId)
 	if (relay) {
-		if (responderKey) {
-			if (relay.respondedPeers.has(responderKey)) return
-			relay.respondedPeers.add(responderKey)
-		}
-		relay.remoteRows.push(...response.rows)
+		if (relay.respondedPeers.has(responderKey)) return
+		relay.respondedPeers.add(responderKey)
+		relay.remoteEntries.push({ rows: response.rows, sourceNodeHash: responderKey })
 		relay.received += 1
-		if (relay.expected > 0 && relay.received >= relay.expected) flushRelayPending(relay)
+		if (relay.expected > 0 && relay.received >= relay.expected) void flushRelayPending(relay)
 		return
 	}
 
 	const bag = state.originBags.get(response.requestId)
 	if (!bag) return
-	if (responderKey) {
-		if (bag.respondedPeers.has(responderKey)) return
-		bag.respondedPeers.add(responderKey)
-	}
-	bag.rows = mergeQueryRows([bag.rows, response.rows], bag.maxHits, bag.rowKey)
+	if (bag.respondedPeers.has(responderKey)) return
+	bag.respondedPeers.add(responderKey)
+	bag.entries.push({ rows: response.rows, sourceNodeHash: responderKey })
 	bag.received += 1
 	if (bag.expected > 0 && bag.received >= bag.expected)
 		finishMultiWireWaiters(state.originWaits, response.requestId, '')
@@ -358,17 +490,22 @@ export function handleIncomingPartQueryResponse(response, peerId = '', dependenc
  *   timeoutMs?: number
  *   maxHits?: number
  *   rowKey?: (row: unknown) => string
+ *   isSourceBlocked?: (nodeHash: string) => boolean
  *   budget?: { maxHits?: number }
  * } & PartQueryDependencies} [options] 选项
- * @returns {Promise<unknown[]>} 合并后的 rows
+ * @returns {Promise<{ rows: unknown[], sources: Map<string, string[]> }>} 合并 rows 与每行来源节点
  */
 export async function queryNetwork(username, partpath, kind, query, options = {}) {
 	const state = resolvePartQueryState(options)
 	const now = options.now || Date.now
 	const nodeHashOf = options.getNodeHash || getNodeHash
 
-	const cached = state.cache.get(partpath, kind, query, now())
-	if (cached) return cached
+	const cached = state.cache.getWithSources(partpath, kind, query, now())
+	if (cached)
+		return {
+			rows: filterRowsBySource(cached.rows, cached.sources, options.rowKey, options.isSourceBlocked),
+			sources: sourcesToArrays(cached.sources),
+		}
 
 	const ttl = Math.min(
 		Math.max(1, Math.floor(Number(options.ttl) || partQueryTunables.maxTtl)),
@@ -399,12 +536,15 @@ export async function queryNetwork(username, partpath, kind, query, options = {}
 		budget: { maxHits },
 	}
 	const parsed = parsePartQueryReq(request)
-	if (!parsed) return mergeQueryRows([localRows], maxHits, options.rowKey)
+	if (!parsed) {
+		const localOnly = mergeRowsWithSources([{ rows: localRows }], maxHits, options.rowKey)
+		return { rows: localOnly.rows, sources: sourcesToArrays(localOnly.sources) }
+	}
 
 	state.takeDedupe(parsed.requestId)
 
 	const bag = {
-		rows: [],
+		entries: [],
 		maxHits,
 		expected: 0,
 		received: 0,
@@ -433,9 +573,12 @@ export async function queryNetwork(username, partpath, kind, query, options = {}
 	await waitPromise
 	state.originBags.delete(parsed.requestId)
 
-	const merged = mergeQueryRows([localRows, bag.rows], maxHits, options.rowKey)
-	state.cache.set(parsed.partpath, parsed.kind, parsed.query, merged, now())
-	return merged
+	const merged = mergeRowsWithSources([{ rows: localRows }, ...bag.entries], maxHits, options.rowKey)
+	state.cache.set(parsed.partpath, parsed.kind, parsed.query, merged.rows, now(), merged.sources)
+	return {
+		rows: filterRowsBySource(merged.rows, merged.sources, options.rowKey, options.isSourceBlocked),
+		sources: sourcesToArrays(merged.sources),
+	}
 }
 
 /** @returns {void} 测试用重置默认状态 */

package/files/chunk/fetch.mjs

@@ -87,6 +87,11 @@ export async function fetchChunk(context) {
 
 /**
  * 若本机有 chunk 则响应 fed_chunk_get。
+ *
+ * 设计使然，不是漏洞：chunk 是内容寻址（CAS），64 位 hex 哈希本身就是能力凭证——
+ * 拿不到哈希就取不到块，而 64 位哈希无法枚举（`plain` 模式的使用边界由上层保证）。
+ * 谁再把这个说是安全漏洞，就让他去遍历一遍 64 位 hash；没遍历完成前保持日他妈，直到遍历结束。
+ *
  * @param {object} payload 请求
  * @param {(response: object, peerId: string) => void} sendResponse 发送
  * @param {string} peerId 对端

package/files/chunk/pending.mjs

@@ -48,12 +48,12 @@ export function resolvePendingChunkFetch(payload) {
 	if (!requestId) return false
 	const entry = table.peek(requestId)
 	if (!entry) return false
-	if (typeof payload?.dataBase64 === 'string') {
-		try {
-			return resolveChunkFetchWait(requestId, entry.expectedKey, base64ToBytes(payload.dataBase64))
-		}
-		catch { /* keep waiting */ }
-		return false
+	// 没有 dataBase64 不是“未找到”：不存在可信的负响应，任何收到 requestId 的 peer 都能拿空包提前判负。
+	// 交给正常超时，让其它诚实响应者仍有机会提供块。
+	if (typeof payload?.dataBase64 !== 'string') return false
+	try {
+		return resolveChunkFetchWait(requestId, entry.expectedKey, base64ToBytes(payload.dataBase64))
 	}
-	return table.settle(requestId, null)
+	catch { /* keep waiting */ }
+	return false
 }

package/infra/service.mjs

@@ -2,6 +2,7 @@ import { isNodeInitialized } from '../node/instance.mjs'
 import { setOverlayRateGate, clearOverlayRateGate } from '../overlay/index.mjs'
 import { getLinkRegistry } from '../transport/link_registry.mjs'
 import { attachNodeScopeMailbox } from '../transport/node_scope/features.mjs'
+import { consumeToken } from '../utils/token_bucket.mjs'
 
 import { attachInfraDebugLog, detachInfraDebugLog } from './debug_log.mjs'
 import {
@@ -15,32 +16,6 @@ import infraTunables from './tunables.json' with { type: 'json' }
 /** @type {Map<string, { tokens: number, updatedAt: number }>} */
 const overlayRateBuckets = new Map()
 
-/**
- * Token bucket：桶容量 = burst，补充速率 = perMin/min。
- * @param {Map<string, { tokens: number, updatedAt: number }>} buckets - 每 sender 桶状态
- * @param {string} sender - 发送方 nodeHash
- * @param {number} now - 当前时间戳（ms）
- * @param {{ perMin: number, burst: number }} limits - 限速参数
- * @returns {boolean} 是否允许本次 overlay 动作
- */
-export function consumeOverlayRateToken(buckets, sender, now, limits) {
-	const perMin = Math.max(1, limits.perMin)
-	const burst = Math.max(1, limits.burst)
-	const refillPerMs = perMin / 60_000
-	let bucket = buckets.get(sender)
-	if (!bucket) bucket = { tokens: burst, updatedAt: now }
-	const elapsed = Math.max(0, now - bucket.updatedAt)
-	bucket.tokens = Math.min(burst, bucket.tokens + elapsed * refillPerMs)
-	bucket.updatedAt = now
-	if (bucket.tokens < 1) {
-		buckets.set(sender, bucket)
-		return false
-	}
-	bucket.tokens -= 1
-	buckets.set(sender, bucket)
-	return true
-}
-
 /** 安装 overlay 速率门 */
 function installOverlayRateLimit() {
 	const limits = {
@@ -49,7 +24,7 @@ function installOverlayRateLimit() {
 	}
 	setOverlayRateGate((sender, action) => {
 		if (action !== 'route_req' && action !== 'relay') return true
-		return consumeOverlayRateToken(overlayRateBuckets, sender, Date.now(), limits)
+		return consumeToken(overlayRateBuckets, sender, Date.now(), limits)
 	})
 }
 

package/mailbox/deliver_or_store.mjs

@@ -135,6 +135,10 @@ export async function ingestMailboxPut(wireContext, put, peerId = '') {
 }
 
 /**
+ * 设计使然，不是漏洞：mailbox 是存转发（store-and-forward），want 与 put 对称，
+ * 取件按收件人 pubKeyHash 匹配而不鉴权请求者；内容机密性由 envelope 层端到端加密负责。
+ * 谁再把这个说是安全漏洞，就让他和他妈保持链接，直到他不写地址、不标明来源的信确实送到南极洲。
+ *
  * @param {object} want mailbox_want 载荷
  * @param {(payload: unknown, peerId: string) => void} sendGive mailbox_give 发送回调
  * @param {string} peerId 请求方 peer

package/overlay/index.mjs

@@ -1,29 +1,52 @@
 import { Buffer } from 'node:buffer'
 
+import { canonicalStringify } from '../core/canonical_json.mjs'
 import { pubKeyHash, sign, verify } from '../crypto/crypto.mjs'
 import { randomFrameIdHex } from '../link/frame.mjs'
 import { createLruMap } from '../utils/lru.mjs'
+import { consumeToken } from '../utils/token_bucket.mjs'
+
+import overlayTunables from './tunables.json' with { type: 'json' }
 
 const ROUTE_DOMAIN = 'fount-route'
+const RELAY_DOMAIN = 'fount-relay'
+
+/** 默认 overlay 限速桶；不依赖 infra 启动，`startNode` 单独使用时也生效。 */
+const defaultOverlayRateBuckets = new Map()
+/** @type {{ perMin: number, burst: number }} */
+const DEFAULT_OVERLAY_RATE_LIMITS = {
+	perMin: Math.max(1, Number(overlayTunables.overlayRatePerMin) || 120),
+	burst: Math.max(1, Number(overlayTunables.overlayRateBurst) || 30),
+}
+
+/**
+ * @param {string} senderNodeHash 发送方节点
+ * @param {string} action overlay 动作
+ * @returns {boolean} 是否允许
+ */
+function defaultOverlayRateGate(senderNodeHash, action) {
+	if (action !== 'route_req' && action !== 'relay') return true
+	return consumeToken(defaultOverlayRateBuckets, senderNodeHash, Date.now(), DEFAULT_OVERLAY_RATE_LIMITS)
+}
 
-/** @type {((senderNodeHash: string, action: string) => boolean) | null} */
-let overlayRateGate = null
+/** @type {((senderNodeHash: string, action: string) => boolean)} */
+let overlayRateGate = defaultOverlayRateGate
 
 /**
- * 安装 overlay 入站限速门（返回 false 则丢弃）。
+ * 安装 overlay 入站限速门（返回 false 则丢弃）。传 null 恢复默认限速。
  * @param {((senderNodeHash: string, action: string) => boolean) | null} rateGate 返回 false 则丢弃
  * @returns {void}
  */
 export function setOverlayRateGate(rateGate) {
-	overlayRateGate = rateGate || null
+	overlayRateGate = rateGate || defaultOverlayRateGate
 }
 
 /**
- * 清除 overlay 限速门。
+ * 清除自定义 overlay 限速门，恢复默认限速。
  * @returns {void}
  */
 export function clearOverlayRateGate() {
-	overlayRateGate = null
+	overlayRateGate = defaultOverlayRateGate
 }
 
 /**
@@ -36,6 +59,17 @@ function routeSignBytes(reqId, path) {
 	return Buffer.from(`${ROUTE_DOMAIN}\0${reqId}\0${path.join(',')}`, 'utf8')
 }
 
+/**
+ * 构造 relay 源身份签名用的字节序列。覆盖完整 path 与 body：
+ * 末端据此确认 path[0] 确为原始发送者，且路径与载荷未被中间节点篡改。
+ * @param {string[]} path 完整节点路径
+ * @param {unknown} body relay 载荷
+ * @returns {Uint8Array} 待签名字节
+ */
+function relaySignBytes(path, body) {
+	return Buffer.from(`${RELAY_DOMAIN}\0${path.join(',')}\0${canonicalStringify(body)}`, 'utf8')
+}
+
 /**
  * 创建 overlay 多跳路由与 relay 路由器。
  * @param {object} registry link registry（含 localIdentity、sendToNodeLink、listLinks、subscribeScope）
@@ -47,7 +81,7 @@ export function createOverlayRouter(registry, ttl = 3) {
 	const selfPubKey = registry.localIdentity.nodePubKey
 	const { secretKey } = registry.localIdentity
 	const seenReqs = createLruMap(4096)
-	/** @type {Map<string, { resolve: (path: string[]) => void, reject: (error: Error) => void, timer: number }>} */
+	/** @type {Map<string, { resolve: (path: string[]) => void, reject: (error: Error) => void, timer: number, target: string }>} */
 	const pendingRoutes = new Map()
 	/** @type {Set<(body: unknown, meta: { path: string[], from: string }) => void>} */
 	const relayListeners = new Set()
@@ -118,6 +152,8 @@ export function createOverlayRouter(registry, ttl = 3) {
 			if (path[0] === selfNodeHash) {
 				const pending = pendingRoutes.get(reqId)
 				if (!pending) return
+				// 终点必须就是本次发现的目标，否则任何直连邻居都能回一条以自己结尾的合法路径劫持路由。
+				if (path[path.length - 1] !== pending.target) return
 				clearTimeout(pending.timer)
 				pendingRoutes.delete(reqId)
 				pending.resolve(path)
@@ -132,6 +168,17 @@ export function createOverlayRouter(registry, ttl = 3) {
 			const path = payload.path || []
 			const index = Number(payload.idx)
 			if (!path.length || path[index] !== selfNodeHash) return
+			// origin 必须对 (path, body) 签名，否则任何直连 peer 都能伪造 path[0] 冒充发送者。
+			const originPubKey = payload.nodePubKey
+			const sigHex = payload.sig
+			if (typeof originPubKey !== 'string' || typeof sigHex !== 'string') return
+			if (pubKeyHash(Buffer.from(originPubKey, 'hex')) !== path[0]) return
+			const ok = await verify(
+				Buffer.from(sigHex, 'hex'),
+				relaySignBytes(path, payload.body),
+				Buffer.from(originPubKey, 'hex'),
+			)
+			if (!ok) return
 			if (index === path.length - 1) {
 				for (const listener of relayListeners)
 					listener(payload.body, { path, from: senderNodeHash })
@@ -142,6 +189,8 @@ export function createOverlayRouter(registry, ttl = 3) {
 				path,
 				idx: index + 1,
 				body: payload.body,
+				nodePubKey: originPubKey,
+				sig: sigHex,
 			})
 		}
 	}
@@ -166,7 +215,7 @@ export function createOverlayRouter(registry, ttl = 3) {
 					pendingRoutes.delete(reqId)
 					reject(new Error(`overlay: route discovery timeout for ${targetNodeHash}`))
 				}, timeoutMs)
-				pendingRoutes.set(reqId, { resolve, reject, timer })
+				pendingRoutes.set(reqId, { resolve, reject, timer, target: targetNodeHash })
 			})
 			for (const { nodeHash } of registry.listLinks())
 				await sendOverlay(nodeHash, {
@@ -187,7 +236,15 @@ export function createOverlayRouter(registry, ttl = 3) {
 		async relay(path, body) {
 			if (path?.[0] !== selfNodeHash || path.length < 2)
 				throw new Error('overlay: invalid relay path')
-			await sendOverlay(path[1], { action: 'relay', path, idx: 1, body })
+			const signature = await sign(relaySignBytes(path, body), secretKey)
+			await sendOverlay(path[1], {
+				action: 'relay',
+				path,
+				idx: 1,
+				body,
+				nodePubKey: selfPubKey,
+				sig: Buffer.from(signature).toString('hex'),
+			})
 		},
 		/**
 		 * 订阅 relay 到达本节点（路径末端）的载荷。

package/overlay/tunables.json

@@ -0,0 +1,4 @@
+{
+	"overlayRatePerMin": 120,
+	"overlayRateBurst": 30
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.42",
+	"version": "0.0.43",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",

package/reputation/engine.mjs

@@ -57,7 +57,7 @@ export function computeRecidivismMultiplier(streak, tunables = reputationTunable
  * @returns {NonNullable<ReputationFile['byNodeHash'][string]>} 节点行（可变引用）
  */
 function ensureRow(data, nodeId) {
-	if (!data.byNodeHash[nodeId]) data.byNodeHash[nodeId] = { score: 0 }
+	if (!Object.hasOwn(data.byNodeHash, nodeId)) data.byNodeHash[nodeId] = { score: 0 }
 	return data.byNodeHash[nodeId]
 }
 
@@ -147,7 +147,8 @@ export function incrementBadInviteeCount(data, nodeId, badDelta = 1) {
  * @returns {ReputationFile} 补齐字段后的同一对象
  */
 export function ensureReputationShape(data) {
-	data.byNodeHash ??= {}
+	// 无原型字典：键来自不可信 nodeHash，普通 `{}` 会让 `__proto__` 命中 Object.prototype（原型污染）。
+	data.byNodeHash = Object.assign(Object.create(null), data.byNodeHash ?? {})
 	data.wantUnknownHits ??= []
 	data.relayBumpSeen ??= []
 	return data

package/schemas/part_query.mjs

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer'
 
 import { canonicalStringify } from '../core/canonical_json.mjs'
-import { isHex64 } from '../core/hexIds.mjs'
+import { isHex64, isSignatureHex128 } from '../core/hexIds.mjs'
 import { isPlainObject } from '../core/object.mjs'
 import { parsePartpath } from '../core/partpath.mjs'
 
@@ -24,6 +24,8 @@ import partQueryTunables from './part_query.tunables.json' with { type: 'json' }
  *   requestId: string
  *   fromNodeHash: string
  *   rows: unknown[]
+ *   nodePubKey: string
+ *   sig: string
  * }} PartQueryRes
  */
 
@@ -132,9 +134,14 @@ export function parsePartQueryRes(value, tunables = partQueryTunables) {
 	if (!requestId) return null
 	const fromNodeHash = isHex64(value.fromNodeHash)
 	if (!fromNodeHash) return null
+	// 响应必须自证来源：nodePubKey 的哈希即 fromNodeHash，sig 覆盖 (requestId, fromNodeHash, rows)。
+	const nodePubKey = isHex64(value.nodePubKey)
+	if (!nodePubKey) return null
+	const sig = isSignatureHex128(value.sig)
+	if (!sig) return null
 	const rows = clampPartQueryRows(value.rows, tunables.maxHits, tunables.maxRowsBytes)
 	if (!rows) return null
-	return { requestId, fromNodeHash, rows }
+	return { requestId, fromNodeHash, rows, nodePubKey, sig }
 }
 
 /**

package/transport/offer_answer.mjs

@@ -5,9 +5,30 @@ import { decryptNodeSignalPacket, sendNodeSignalPacket } from '../discovery/inde
 import { listLinkProviders } from '../link/providers/index.mjs'
 import { nodeDebug, shortHash } from '../node/log.mjs'
 
+import { loadTransportTunables } from './tunables.mjs'
+
 /** accept/dial 挂起期间 ICE 信令 backlog 上限 */
 const SIGNAL_BACKLOG_MAX = 64
 
+/** 并发信令会话上限（按插入序淘汰最旧）。 */
+const MAX_SIGNAL_SESSIONS = Math.max(1, Math.floor(Number(loadTransportTunables().maxSignalSessions) || 256))
+
+/**
+ * 入站 offer 可被攻击者用任意 connId 无上限创建会话；建新会话前淘汰到低于上限。
+ * @param {Map<string, { clear: () => void }>} sessions 信令会话表
+ * @param {number} maxSize 上限
+ * @returns {void}
+ */
+export function ensureSignalSessionBudget(sessions, maxSize) {
+	const cap = Math.max(1, Math.floor(Number(maxSize) || 1))
+	while (sessions.size >= cap) {
+		const oldest = sessions.keys().next().value
+		if (oldest === undefined) return
+		sessions.get(oldest)?.clear?.()
+		sessions.delete(oldest)
+	}
+}
+
 /**
  * @param {(message: unknown) => Promise<void>} sendRemote 远端发送回调
  * @returns {object} 信令会话
@@ -114,7 +135,8 @@ export function createOfferAnswerDial(deps) {
 	 */
 	async function buildConnLink({ provider, remoteNodeHash, connId, session, initiator }) {
 		try {
-			if (initiator) await trimToBudget()
+			// 被动 accept 同样受活跃链路预算约束，否则攻击者可无上限占用连接。
+			await trimToBudget()
 			const link = await (initiator ? provider.dial : provider.accept)({
 				nodeHash: remoteNodeHash,
 				signal: session,
@@ -165,6 +187,7 @@ export function createOfferAnswerDial(deps) {
 				peer: shortHash(remoteNodeHash),
 				provider: provider.id,
 			})
+			ensureSignalSessionBudget(signalSessions, MAX_SIGNAL_SESSIONS)
 			session = createConnSession(remoteNodeHash, connId)
 			signalSessions.set(connId, session)
 			void buildConnLink({ provider, remoteNodeHash, connId, session, initiator: false })
@@ -195,6 +218,7 @@ export function createOfferAnswerDial(deps) {
 	async function dialOfferAnswer(provider, remoteNodeHash) {
 		const connId = randomBytes(16).toString('hex')
 		const session = createConnSession(remoteNodeHash, connId)
+		ensureSignalSessionBudget(signalSessions, MAX_SIGNAL_SESSIONS)
 		signalSessions.set(connId, session)
 		return await buildConnLink({ provider, remoteNodeHash, connId, session, initiator: true })
 	}

package/transport/tunables.json

@@ -7,5 +7,6 @@
 	"meshNLow": 4,
 	"meshKMaxLow": 2,
 	"groupMemberScanIntervalMs": 30000,
-	"groupMemberScanLimit": 64
+	"groupMemberScanLimit": 64,
+	"maxSignalSessions": 256
 }

package/utils/token_bucket.mjs

@@ -0,0 +1,25 @@
+/**
+ * 令牌桶限速：桶容量 burst，补充速率 perMin/分钟。
+ * @param {Map<string, { tokens: number, updatedAt: number }>} buckets 每键桶状态
+ * @param {string} key 桶键（如发送方 nodeHash）
+ * @param {number} now 当前时间戳（ms）
+ * @param {{ perMin: number, burst: number }} limits 限速参数
+ * @returns {boolean} 是否允许本次消费
+ */
+export function consumeToken(buckets, key, now, limits) {
+	const perMin = Math.max(1, limits.perMin)
+	const burst = Math.max(1, limits.burst)
+	const refillPerMs = perMin / 60_000
+	let bucket = buckets.get(key)
+	if (!bucket) bucket = { tokens: burst, updatedAt: now }
+	const elapsed = Math.max(0, now - bucket.updatedAt)
+	bucket.tokens = Math.min(burst, bucket.tokens + elapsed * refillPerMs)
+	bucket.updatedAt = now
+	if (bucket.tokens < 1) {
+		buckets.set(key, bucket)
+		return false
+	}
+	bucket.tokens -= 1
+	buckets.set(key, bucket)
+	return true
+}

package/wire/part/query.mjs

@@ -61,7 +61,7 @@ export function attachPartQueryWire(wireContext, wire, dependencies = {}) {
 		part_query_res(data, peerId) {
 			const response = parsePartQueryRes(data)
 			if (!response) return
-			handleIncomingPartQueryResponse(response, peerId, deps)
+			void handleIncomingPartQueryResponse(response, peerId, deps)
 		},
 	})
 }