215 lines
20 KiB
TypeScript
215 lines
20 KiB
TypeScript
/** Optional fixed direct-peer observation component. No RIB/BGP dump, route evaluator,
|
|
* mutable native command, DNS/NAT certification or dispatch authority. */
|
|
import http from "node:http"
|
|
import https from "node:https"
|
|
import { createHash } from "node:crypto"
|
|
import { isDeepStrictEqual } from "node:util"
|
|
import { performance } from "node:perf_hooks"
|
|
import { z } from "zod"
|
|
import { canonicalBandwidthNodeValue as canonical } from "./bandwidth-node-bootstrap.js"
|
|
import { createBandwidthPeerObservationReader, type BandwidthPeerTrustedSource, type BandwidthPeerSourceSnapshot, type BandwidthPeerObservationEvidence } from "./bandwidth-peer-observation.js"
|
|
import { parseBandwidthPeerRef } from "./bandwidth-peer-reference.js"
|
|
import type { BandwidthScope } from "./bandwidth-admission.js"
|
|
import { isIP } from "node:net"
|
|
|
|
const MAX_GETTERS = 32, MAX_ROWS = 2048
|
|
type Row = Readonly<Record<string, unknown>>
|
|
const label = z.string().min(1).max(128).regex(/^[^\u0000-\u001f\u007f%@]+$/)
|
|
const ref = z.unknown().transform(parseBandwidthPeerRef)
|
|
const planSchema = z.discriminatedUnion("role", [
|
|
z.object({ role: z.literal("source"), peerRef: ref, wireAddress: z.string().min(1).max(1024), sourceInterface: label }).strict(),
|
|
z.object({ role: z.literal("remote"), peerRef: ref, wireAddress: z.string().min(1).max(1024), remoteInterface: label }).strict(),
|
|
])
|
|
export type BandwidthPeerDirectObservationPlan = z.infer<typeof planSchema>
|
|
const endpointSchema = z.object({ host: z.string().min(1).max(1000).regex(/^[^\s/\\\u0000-\u001f\u007f]+$/), port: z.number().int().min(1).max(65535), useSsl: z.boolean(), verifySsl: z.boolean(), username: z.string().max(1000), password: z.string().max(65536), routingEndpointEpoch: z.string().uuid() }).strict()
|
|
const sourceSchema = z.object({ peerRef: ref, enabled: z.literal(true), sourceProof: z.string().regex(/^[a-f0-9]{64}$/), authorityGeneration: z.string().min(1).max(200), endpoint: endpointSchema }).strict()
|
|
export class BandwidthPeerDirectObservationError extends Error {
|
|
readonly code = "BANDWIDTH_PEER_DIRECT_OBSERVATION_REFUSED"
|
|
constructor() { super("Direct peer observation refused") }
|
|
}
|
|
const fail = (): never => { throw new BandwidthPeerDirectObservationError() }
|
|
/** Fixed literal grammar, separate from a mapping grant or command builder.
|
|
* Exact input is retained; this parser never substitutes a management host. */
|
|
export function parseBandwidthPeerDirectWireAddress(address: string) {
|
|
if (typeof address !== "string" || !address.length || address.length > 1024 || /[\u0000-\u001f\u007f]/.test(address)) return fail()
|
|
const tableParts = address.split("@"); if (tableParts.length > 2 || tableParts.some(part => !part.length)) fail()
|
|
const zoneParts = tableParts[0].split("%"); if (zoneParts.length > 2 || zoneParts.some(part => !part.length)) fail()
|
|
const host = zoneParts[0], family = isIP(host), zone = zoneParts[1] ?? null, routingTable = tableParts[1] ?? "main"
|
|
if (!family || zone && family !== 6 || Buffer.byteLength(routingTable) > 128 || zone && Buffer.byteLength(zone) > 128 || /[%@]/.test(routingTable)) fail()
|
|
if (family === 6 && /^fe[89ab]/i.test(host) && !zone) fail()
|
|
return Object.freeze({ address, host, family: family === 4 ? "ipv4" as const : "ipv6" as const, routingTable, zone })
|
|
}
|
|
function freeze<T>(value: T): T { if (value && typeof value === "object") { Object.values(value).forEach(freeze); Object.freeze(value) } return value }
|
|
function copy(raw: unknown, maxBytes = 1048576): unknown {
|
|
let nodes = 0
|
|
const walk = (value: unknown, depth = 0): unknown => {
|
|
if (++nodes > 20000 || depth > 8) return fail()
|
|
if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value
|
|
if (!value || typeof value !== "object") return fail()
|
|
const array = Array.isArray(value), fields = Object.getOwnPropertyDescriptors(value)
|
|
if (Object.getPrototypeOf(value) !== (array ? Array.prototype : Object.prototype) || Reflect.ownKeys(value).some(key => typeof key !== "string")) fail()
|
|
if (array) {
|
|
const length = fields.length.value as number
|
|
if (length > MAX_ROWS || Object.keys(fields).length !== length + 1) fail()
|
|
return Object.freeze(Array.from({ length }, (_, index) => { const item = fields[String(index)]; if (!item || !("value" in item) || !item.enumerable) return fail(); return walk(item.value, depth + 1) }))
|
|
}
|
|
const result: Record<string, unknown> = {}
|
|
for (const [key, item] of Object.entries(fields)) { if (!("value" in item) || !item.enumerable || key === "__proto__" || Buffer.byteLength(key) > 128) fail(); Object.defineProperty(result, key, { value: walk(item.value, depth + 1), enumerable: true }) }
|
|
return Object.freeze(result)
|
|
}
|
|
const value = walk(raw); if (Buffer.byteLength(JSON.stringify(value)) > maxBytes) fail(); return value
|
|
}
|
|
const flag = (value: unknown) => value === true || value === "true" || value === "yes" ? true : value === false || value === "false" || value === "no" ? false : undefined
|
|
function rows(raw: unknown, maximum: number): readonly Row[] {
|
|
const value = copy(raw)
|
|
if (!Array.isArray(value) || value.length > maximum || value.some(row => !row || typeof row !== "object" || Array.isArray(row) || typeof row[".id"] !== "string" || !/^\*[a-z0-9]+$/i.test(row[".id"])) || new Set(value.map(row => row[".id"])).size !== value.length) return fail()
|
|
return value as readonly Row[]
|
|
}
|
|
function unique(values: readonly Row[], field: string, wanted: string): Row { const found = values.filter(row => row[field] === wanted); if (found.length !== 1) return fail(); return found[0] }
|
|
function sameAddress(left: string, right: string) { try { return new URL("http://[" + left + "]").hostname === new URL("http://[" + right + "]").hostname } catch { return left === right } }
|
|
declare const profileBrand: unique symbol
|
|
export type BandwidthPeerDirectObservation = Readonly<{ kind: "routeros-peer-direct-observation"; [profileBrand]: true }>
|
|
export interface BandwidthPeerDirectObservationEvidence {
|
|
readonly profile: "bandwidth-peer-direct-observation-v1"
|
|
readonly plan: Readonly<BandwidthPeerDirectObservationPlan>
|
|
readonly identity: Readonly<BandwidthPeerObservationEvidence>
|
|
readonly observedAt: number; readonly expiresAt: number
|
|
readonly snapshotSha256: string
|
|
readonly facts: Readonly<{ address?: string; interface: string; routingTable?: string; orderedVrfOwner?: string; currentPolicyAllDisabled?: true }>
|
|
readonly acquisition: Readonly<{ catalogueGets: number; effectiveDefaultGets: number; licenseGets: 2; fullRibRead: false }>
|
|
readonly effectiveRoutingVerified: false; readonly effectiveNatVerified: false
|
|
readonly connectionTrackingVerified: false; readonly configurationFenceHeld: false; readonly nativeDispatchAdmissible: false
|
|
}
|
|
type Origin = { source: Readonly<BandwidthPeerSourceSnapshot>; evidence: Readonly<BandwidthPeerDirectObservationEvidence>; end: number; signal?: AbortSignal }
|
|
export function createBandwidthPeerDirectObservationReader(trustedSource: BandwidthPeerTrustedSource) {
|
|
if (!trustedSource || typeof trustedSource.read !== "function") fail()
|
|
const read = trustedSource.read.bind(trustedSource), licenses = createBandwidthPeerObservationReader({ read }), origins = new WeakMap<object, Origin>(), windows = new Set<AbortController>()
|
|
let closed = false
|
|
async function operation<T>(raw: BandwidthScope, origin: Origin | undefined, work: (owned: { scope: Readonly<BandwidthScope>; live(): void; wait<V>(work: () => Promise<V>): Promise<V>; end: number; external?: AbortSignal }) => Promise<T>): Promise<T> {
|
|
if (!raw || Object.getPrototypeOf(raw) !== Object.prototype) return fail()
|
|
const descriptors = Object.getOwnPropertyDescriptors(raw)
|
|
if (Reflect.ownKeys(raw).length !== Object.keys(descriptors).length || Object.values(descriptors).some(item => !("value" in item) || !item.enumerable) || Object.keys(descriptors).some(key => !["deadlineAt", "signal"].includes(key))) fail()
|
|
const deadline = descriptors.deadlineAt?.value as number, external = descriptors.signal?.value as AbortSignal | undefined
|
|
if (!Number.isSafeInteger(deadline) || external !== undefined && !(external instanceof AbortSignal)) fail()
|
|
const wall = Date.now(), mono = performance.now(), deadlineAt = Math.min(deadline, wall + 5000, origin?.evidence.expiresAt ?? Infinity), end = Math.min(mono + Math.max(0, deadlineAt - wall), origin?.end ?? Infinity)
|
|
const controller = new AbortController(), abort = () => controller.abort(), scope = Object.freeze({ deadlineAt, signal: controller.signal })
|
|
const live = () => { if (closed || controller.signal.aborted || external?.aborted || origin?.signal?.aborted || Date.now() >= deadlineAt || performance.now() >= end) fail() }
|
|
live(); windows.add(controller); external?.addEventListener("abort", abort, { once: true }); origin?.signal?.addEventListener("abort", abort, { once: true }); const timer = setTimeout(abort, Math.max(1, end - mono))
|
|
const wait = async <V>(fn: () => Promise<V>): Promise<V> => {
|
|
live(); let cancel!: () => void
|
|
const stopped = new Promise<never>((_resolve, reject) => { cancel = () => reject(new BandwidthPeerDirectObservationError()); controller.signal.addEventListener("abort", cancel, { once: true }) })
|
|
try { const value = await Promise.race([Promise.resolve().then(() => { live(); return fn() }), stopped]); live(); return value } finally { controller.signal.removeEventListener("abort", cancel) }
|
|
}
|
|
try { return await work({ scope, live, wait, end, external }) } catch { throw new BandwidthPeerDirectObservationError() }
|
|
finally { clearTimeout(timer); windows.delete(controller); external?.removeEventListener("abort", abort); origin?.signal?.removeEventListener("abort", abort); controller.abort() }
|
|
}
|
|
return Object.freeze({
|
|
async observe(rawPlan: BandwidthPeerDirectObservationPlan, rawScope: BandwidthScope): Promise<BandwidthPeerDirectObservation> {
|
|
const plan = freeze(planSchema.parse(copy(rawPlan))), wire = parseBandwidthPeerDirectWireAddress(plan.wireAddress)
|
|
if (plan.role === "source" && plan.peerRef.kind !== "server" || plan.role === "source" && wire.zone && wire.zone !== plan.sourceInterface) fail()
|
|
return operation(rawScope, undefined, async owned => {
|
|
const before = freeze(sourceSchema.parse(copy(await owned.wait(() => read(plan.peerRef, owned.scope)))))
|
|
if (!isDeepStrictEqual(before.peerRef, plan.peerRef)) fail()
|
|
const fresh = async () => { if (!isDeepStrictEqual(sourceSchema.parse(copy(await owned.wait(() => read(plan.peerRef, owned.scope)))), before)) fail() }
|
|
const identityToken = await owned.wait(() => licenses.observe(plan.peerRef, owned.scope)); await fresh()
|
|
const identity = await owned.wait(() => licenses.inspect(identityToken, owned.scope)); await fresh()
|
|
const { MikrotikClient } = await owned.wait(() => import("./mikrotik.js")); await fresh()
|
|
const client = new MikrotikClient(before.endpoint), snapshots: unknown[] = [], defaults: unknown[] = []
|
|
let calls = 0, getters = 0, totalRows = 0, totalBytes = 0
|
|
const get = async (resource: string, maximum: number) => {
|
|
await fresh(); calls++
|
|
const value = rows(await owned.wait(() => client.get<unknown>(resource, Math.max(1, owned.scope.deadlineAt - Date.now()), owned.scope.signal, resource === "/interface" ? 262144 : 131072, fresh)), maximum)
|
|
await fresh(); totalRows += value.length; totalBytes += Buffer.byteLength(JSON.stringify(value))
|
|
if (totalRows > MAX_ROWS || totalBytes > 1048576) fail()
|
|
// Interface traffic counters do not describe the mapping. Preserve
|
|
// every policy property; only known interface telemetry is excluded.
|
|
const stable = resource === "/interface" ? value.map(row => Object.fromEntries(Object.entries(row).filter(([key]) => !/^(?:rx-|tx-|fp-|last-link-|link-downs$|driver-)/.test(key)))) : value
|
|
snapshots.push({ resource, rows: stable }); return value
|
|
}
|
|
/** Read-only POST /get, with fixed resource/id/property vocabulary and a
|
|
* 4KiB streaming cap. MikrotikClient.post's generic 8MiB response bound
|
|
* is deliberately not used for these scalar defaults. */
|
|
const scalar = async (resource: string, id: unknown, property: "disabled" | "invalid" | "fib") => {
|
|
const allowed = new Set(["/interface", "/ip/address", "/ipv6/address", "/ip/vrf", "/routing/table", "/routing/rule", "/ip/firewall/nat", "/ipv6/firewall/nat", "/ip/firewall/mangle", "/ipv6/firewall/mangle"])
|
|
if (!allowed.has(resource) || typeof id !== "string" || !/^\*[a-z0-9]+$/i.test(id) || ++getters > MAX_GETTERS) fail()
|
|
await fresh()
|
|
const value = await owned.wait(() => new Promise<unknown>((resolveValue, reject) => {
|
|
const endpoint = before.endpoint, transport = endpoint.useSsl ? https : http, body = JSON.stringify({ ".id": id, "value-name": property })
|
|
const request = transport.request({ hostname: endpoint.host, port: endpoint.port, path: "/rest" + resource + "/get", method: "POST", signal: owned.scope.signal, rejectUnauthorized: endpoint.useSsl ? endpoint.verifySsl : undefined,
|
|
headers: { authorization: "Basic " + Buffer.from(endpoint.username + ":" + endpoint.password).toString("base64"), "content-type": "application/json", "content-length": Buffer.byteLength(body) } }, response => {
|
|
const chunks: Buffer[] = []; let bytes = 0
|
|
response.on("error", reject); response.once("aborted", () => reject(new BandwidthPeerDirectObservationError()))
|
|
if (response.statusCode !== 200 || Number(response.headers["content-length"] ?? 0) > 4096) { response.destroy(); request.destroy(new BandwidthPeerDirectObservationError()); return }
|
|
response.on("data", (chunk: Buffer) => { bytes += chunk.length; if (bytes > 4096) { response.destroy(); request.destroy(new BandwidthPeerDirectObservationError()) } else chunks.push(chunk) })
|
|
response.on("end", () => { try { resolveValue(JSON.parse(Buffer.concat(chunks).toString("utf8"))) } catch { reject(new BandwidthPeerDirectObservationError()) } })
|
|
})
|
|
const timer = setTimeout(() => request.destroy(new BandwidthPeerDirectObservationError()), Math.max(1, owned.scope.deadlineAt - Date.now()))
|
|
request.once("close", () => clearTimeout(timer)); request.once("error", reject); request.end(body)
|
|
}))
|
|
await fresh(); const parsed = copy(value, 4096)
|
|
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || Object.keys(parsed).join() !== "ret") fail()
|
|
const ret = flag((parsed as Record<string, unknown>).ret); if (ret === undefined) fail()
|
|
defaults.push({ resource, id, property, value: ret }); return ret
|
|
}
|
|
const boolean = async (resource: string, row: Row, property: "disabled" | "invalid" | "fib") => {
|
|
// Actual RouterOS main tables may print fib:"" while /get fib
|
|
// returns the effective boolean. Keep the raw empty value in the
|
|
// catalogue snapshot and separately record the measured getter.
|
|
if (resource === "/routing/table" && property === "fib" && row.fib === "") return scalar(resource, row[".id"], property)
|
|
if (Object.hasOwn(row, property)) { const value = flag(row[property]); if (value === undefined) return fail(); return value }
|
|
return scalar(resource, row[".id"], property)
|
|
}
|
|
const enabled = async (resource: string, row: Row) => { if (await boolean(resource, row, "disabled")) fail() }
|
|
const interfaces = await get("/interface", 1024), iface = plan.role === "source" ? plan.sourceInterface : plan.remoteInterface
|
|
await enabled("/interface", unique(interfaces, "name", iface))
|
|
let facts: BandwidthPeerDirectObservationEvidence["facts"]
|
|
if (plan.role === "remote") {
|
|
const resource = wire.family === "ipv4" ? "/ip/address" : "/ipv6/address", addresses = await get(resource, 1024)
|
|
const selected = addresses.filter(row => row.interface === iface && typeof row.address === "string" && sameAddress(row.address.split("/")[0], wire.host))
|
|
if (selected.length !== 1) fail()
|
|
await enabled(resource, selected[0]); if (await boolean(resource, selected[0], "invalid")) fail()
|
|
facts = Object.freeze({ address: wire.host, interface: iface })
|
|
} else {
|
|
const tables = await get("/routing/table", 64), table = unique(tables, "name", wire.routingTable)
|
|
if (!await boolean("/routing/table", table, "fib")) fail()
|
|
for (const property of ["disabled", "invalid"] as const) if (Object.hasOwn(table, property) && flag(table[property]) !== false) fail()
|
|
const vrfs = await get("/ip/vrf", 64); let owner: string | undefined
|
|
const names = new Set(interfaces.map(row => row.name))
|
|
for (const row of vrfs) {
|
|
if (await boolean("/ip/vrf", row, "disabled")) continue
|
|
if (Object.hasOwn(row, "invalid") && flag(row.invalid) !== false) fail()
|
|
if (typeof row.interfaces !== "string" || typeof row.name !== "string") return fail()
|
|
const members = row.interfaces.split(",").map(item => item.trim())
|
|
if (members.some(item => !["all", "none"].includes(item) && !names.has(item))) fail()
|
|
if (members.includes("all") || members.includes(iface)) { owner = row.name; break }
|
|
}
|
|
if (owner !== wire.routingTable) fail()
|
|
const base = wire.family === "ipv4" ? "/ip" : "/ipv6"
|
|
for (const resource of ["/routing/rule", base + "/firewall/nat", base + "/firewall/mangle"]) {
|
|
const policy = await get(resource, 256)
|
|
// No matcher interpretation or irrelevant-chain shortcut. Disabled
|
|
// proves this CURRENT rule cannot apply; unknown/enabled refuses.
|
|
for (const row of policy) if (!await boolean(resource, row, "disabled")) fail()
|
|
}
|
|
facts = Object.freeze({ interface: iface, routingTable: wire.routingTable, orderedVrfOwner: owner, currentPolicyAllDisabled: true })
|
|
}
|
|
const finalToken = await owned.wait(() => licenses.observe(plan.peerRef, owned.scope)); await fresh()
|
|
const finalIdentity = await owned.wait(() => licenses.inspect(finalToken, owned.scope)); await fresh()
|
|
const { observedAt: _a, expiresAt: _b, ...firstSubject } = identity, { observedAt: _c, expiresAt: _d, ...lastSubject } = finalIdentity
|
|
if (!isDeepStrictEqual(firstSubject, lastSubject)) fail()
|
|
const snapshotSha256 = createHash("sha256").update("mmapp-bandwidth-peer-direct-observation-v1:" + canonical({ plan, snapshots, defaults, facts })).digest("hex")
|
|
const evidence = freeze({ profile: "bandwidth-peer-direct-observation-v1" as const, plan, identity, observedAt: Date.now(), expiresAt: Math.min(owned.scope.deadlineAt, identity.expiresAt), snapshotSha256, facts,
|
|
acquisition: { catalogueGets: calls, effectiveDefaultGets: getters, licenseGets: 2 as const, fullRibRead: false as const }, effectiveRoutingVerified: false as const, effectiveNatVerified: false as const,
|
|
connectionTrackingVerified: false as const, configurationFenceHeld: false as const, nativeDispatchAdmissible: false as const })
|
|
const token = Object.freeze({ kind: "routeros-peer-direct-observation" as const }) as BandwidthPeerDirectObservation
|
|
origins.set(token, { source: before, evidence, end: owned.end, signal: owned.external }); return token
|
|
})
|
|
},
|
|
async inspect(token: unknown, rawScope: BandwidthScope): Promise<Readonly<BandwidthPeerDirectObservationEvidence>> {
|
|
const origin = token && typeof token === "object" ? origins.get(token) : undefined; if (!origin) return fail()
|
|
return operation(rawScope, origin, async owned => { if (!isDeepStrictEqual(sourceSchema.parse(copy(await owned.wait(() => read(origin.source.peerRef, owned.scope)))), origin.source)) fail(); owned.live(); return origin.evidence })
|
|
},
|
|
close() { closed = true; licenses.close(); for (const controller of windows) controller.abort() },
|
|
})
|
|
}
|