import assert from "node:assert/strict" import { setTimeout as delay } from "node:timers/promises" import Fastify from "fastify" import { createNetworkRoutes } from "../routes/network.js" import { createNetworkHostResolver, resolveHostsSchema } from "./network-host-resolution.js" import { permissionForRequest } from "../lib/permissions.js" assert.equal(permissionForRequest("POST", "/api/network/resolve-hosts"), "mm:network:write") for (const host of ["https://example.com", "example.com:80", "x\ny", "../x", "a;b", "__proto__", "a..b", "-bad", "bad-", "256.1.1.1", "001.2.3.4", "", "x".repeat(64) + ".test"]) assert.equal(resolveHostsSchema.safeParse({ hosts: [host] }).success, false, host) assert.equal(resolveHostsSchema.safeParse({ hosts: Array(33).fill("127.0.0.1") }).success, false) let calls = 0, clock = Date.now() const resolver = createNetworkHostResolver({ now: () => clock, cacheLimit: 1, lookup: async () => { calls++; return { address: "192.0.2.1", family: 4 } } }) let result = await resolver({ hosts: [" Example.Test ", "EXAMPLE.test", "127.0.0.1"] }) assert.equal(calls, 1); assert.equal(Object.keys(result.results).length, 2); assert.equal(result.observations["127.0.0.1"].state, "literal") assert.equal(result.routerResolverVerified, false); assert.equal(result.forwardingVerified, false) assert.equal((await resolver({ hosts: ["::1"] })).observations["::1"].state, "unsupported-family"); assert.equal(calls, 1) let idnCalls = 0 const idn = createNetworkHostResolver({ lookup: async host => { idnCalls++; assert.equal(host, "xn--e1afmkfd.xn--p1ai"); return { address: "192.0.2.10", family: 4 } } }) assert.equal((await idn({ hosts: ["пример.рф", "xn--e1afmkfd.xn--p1ai"] })).results["пример.рф"], "192.0.2.10"); assert.equal(idnCalls, 1) assert.equal((await resolver({ hosts: ["example.test"] })).observations["example.test"].source, "cache"); assert.equal(calls, 1) await resolver({ hosts: ["other.test"] }); await resolver({ hosts: ["example.test"] }); assert.equal(calls, 3) clock += 300001; await resolver({ hosts: ["example.test"] }); assert.equal(calls, 4) result = await resolver({ hosts: ["constructor"] }); assert.equal(Object.getPrototypeOf(result.results), null); assert.equal(result.results.constructor, "192.0.2.1") let negativeCalls = 0 const negative = createNetworkHostResolver({ lookup: async () => { negativeCalls++; throw Error("NEVER_DNS_PROVIDER_SECRET") } }) assert.equal((await negative({ hosts: ["unresolved.test"] })).observations["unresolved.test"].state, "unresolved") assert.equal((await negative({ hosts: ["unresolved.test"] })).observations["unresolved.test"].source, "cache"); assert.equal(negativeCalls, 1) assert.ok(!JSON.stringify(await negative({ hosts: ["unresolved.test"] })).includes("NEVER_")) assert.equal((await createNetworkHostResolver({ lookup: async () => ({ address: "::1", family: 6 }) })({ hosts: ["wrong-family.test"] })).results["wrong-family.test"], null) let release!: (value: { address: string; family: number }) => void, pendingCalls = 0 const pending = new Promise<{ address: string; family: number }>(resolve => { release = resolve }) const bounded = createNetworkHostResolver({ timeoutMs: 10, maxPending: 1, lookup: async host => { pendingCalls++; return host === "held.test" ? pending : { address: "192.0.2.2", family: 4 } } }) result = await bounded({ hosts: ["held.test", "second.test"] }) assert.equal(result.observations["held.test"].state, "timeout"); assert.equal(result.observations["second.test"].state, "busy"); assert.equal(pendingCalls, 1) release({ address: "192.0.2.3", family: 4 }); await delay(0) assert.equal((await bounded({ hosts: ["held.test"] })).observations["held.test"].source, "cache") assert.equal((await bounded({ hosts: ["second.test"] })).results["second.test"], "192.0.2.2"); assert.equal(pendingCalls, 2) let dedupCalls = 0, complete!: (value: { address: string; family: number }) => void const shared = new Promise<{ address: string; family: number }>(resolve => { complete = resolve }) const dedup = createNetworkHostResolver({ timeoutMs: 1000, lookup: async () => { dedupCalls++; return shared } }) const reads = [dedup({ hosts: ["same.test"] }), dedup({ hosts: ["SAME.test"] })] await delay(0); assert.equal(dedupCalls, 1); complete({ address: "192.0.2.4", family: 4 }); await Promise.all(reads) let permitted = true, gatedCalls = 0, allow!: (value: { address: string; family: number }) => void const gate = new Promise<{ address: string; family: number }>(resolve => { allow = resolve }) const guarded = createNetworkHostResolver({ lookup: async () => { gatedCalls++; return gate } }) const read = guarded({ hosts: ["first.test", "next.test"] }, { assertReadable: async () => { if (!permitted) throw Error("Access revoked") } }).then(() => null, error => error) await delay(0); assert.equal(gatedCalls, 1); permitted = false; allow({ address: "192.0.2.5", family: 4 }); assert.match(String(await read), /Access revoked/); assert.equal(gatedCalls, 1) const cancelled = new AbortController(); cancelled.abort() await assert.rejects(guarded({ hosts: ["next.test"] }, { signal: cancelled.signal })); assert.equal(gatedCalls, 1) let budgetClock = 0, budgetCalls = 0 const budgeted = createNetworkHostResolver({ now: () => budgetClock, totalTimeoutMs: 10, lookup: async () => { budgetCalls++; budgetClock += 11; return new Promise(() => {}) } }) result = await budgeted({ hosts: ["budget-one.test", "budget-two.test", "budget-three.test"] }) assert.equal(budgetCalls, 1); assert.ok(Object.values(result.observations).every(row => row.state === "timeout")) let settleAbort!: (value: { address: string; family: number }) => void, abortCalls = 0 const abortGate = new Promise<{ address: string; family: number }>(resolve => { settleAbort = resolve }) const abortResolver = createNetworkHostResolver({ maxPending: 1, lookup: async () => { abortCalls++; return abortGate } }) const midAbort = new AbortController(), abortRead = abortResolver({ hosts: ["abort-one.test", "abort-two.test"] }, { signal: midAbort.signal }).then(() => null, error => error) await delay(0); assert.equal(abortCalls, 1); midAbort.abort(); assert.match(String(await abortRead), /cancelled/) assert.equal((await abortResolver({ hosts: ["abort-two.test"] })).observations["abort-two.test"].state, "busy"); assert.equal(abortCalls, 1) settleAbort({ address: "192.0.2.6", family: 4 }); await delay(0) const app = Fastify(); await app.register(createNetworkRoutes(resolver), { prefix: "/api" }) const beforeInvalid = calls assert.equal((await app.inject({ method: "POST", url: "/api/network/resolve-hosts", payload: { hosts: ["http://invalid.test"] } })).statusCode, 400); assert.equal(calls, beforeInvalid) const http = await app.inject({ method: "POST", url: "/api/network/resolve-hosts", payload: { hosts: ["127.0.0.1", "127.0.0.1"] } }) assert.equal(http.statusCode, 200); assert.deepEqual(http.json(), { results: { "127.0.0.1": "127.0.0.1" } }); await app.close() let httpCalls = 0, started!: () => void, finishHttp!: (value: { address: string; family: number }) => void const httpStarted = new Promise(resolve => { started = resolve }) const httpGate = new Promise<{ address: string; family: number }>(resolve => { finishHttp = resolve }) const httpResolver = createNetworkHostResolver({ maxPending: 1, lookup: async () => { httpCalls++; started(); return httpGate } }) const live = Fastify(); await live.register(createNetworkRoutes(httpResolver), { prefix: "/api" }) const url = await live.listen({ host: "127.0.0.1", port: 0 }) const disconnect = new AbortController() try { const request = fetch(url + "/api/network/resolve-hosts", { method: "POST", headers: { "content-type": "application/json", connection: "close" }, body: JSON.stringify({ hosts: ["http-first.test", "http-next.test"] }), signal: disconnect.signal }).then(() => null, error => error) let startTimer: ReturnType | undefined try { await Promise.race([httpStarted, new Promise((_resolve, reject) => { startTimer = setTimeout(() => reject(new Error("REST request did not reach DNS lookup")), 5000) })]) } finally { clearTimeout(startTimer) } disconnect.abort(); assert.ok(await request) await delay(20) assert.equal(httpCalls, 1) assert.equal((await httpResolver({ hosts: ["http-next.test"] })).observations["http-next.test"].state, "busy") finishHttp({ address: "192.0.2.7", family: 4 }); await delay(0) } finally { disconnect.abort(); finishHttp({ address: "192.0.2.7", family: 4 }); live.server.closeAllConnections(); await live.close() } console.log("Host resolution: strict IPv4/hostname, dedup, bounded cache/TTL, safe unknown, no prototype/provider payload, retained pending capacity after timeout, shared in-flight lookup, revoke/cancel and actual REST parity; no external DNS")