import { z } from "zod" import { wgPatchInterfaceSchema } from "@mmapp/contracts/wireguard" import { getServerRowById, type ServerRow } from "../modules/servers/repository/servers-repository.js" import { fingerprint, McpError, privateFingerprinter } from "../modules/mcp/security.js" import { readWireguardInterfaceDeleteState, planWireguardInterfaceDelete, wireguardInterfaceDeleteProof, type WireguardInterfaceDeleteState } from "./wireguard-interface-delete.js" import { wireguardCreateKey, wireguardPublicKey, wireguardCreateProtectionProof, assertWireguardCreateAllowed } from "./wireguard-interface-create.js" import { observedBoolean, observedInteger } from "./ospf-observed-values.js" import { interfaceAddressKey, interfaceAddressPath } from "./entity-snapshots.js" import { MikrotikClient } from "./mikrotik.js" import { withApplicationMutationLock, withConfigMutationLock } from "./config-mutation-lock.js" import { executeGuardedApplicationWrite } from "./config-mutation-policy.js" import { captureAndAppendRevision } from "./config-revisions.js" import { captureWireguardSnapshot } from "./wireguard-live.js" import { sameWireguardEndpoint } from "./wireguard-source.js" import { greStableRows } from "./gre-mutation-state.js" import { wireguardConfigurationRows } from "./wireguard-peer-delete.js" import { wireguardCorroboratedPrivateScalar, wireguardPrivateScalarsEqual } from "./wireguard-key-scalar.js" const text = z.string().max(1000).refine(value => !/[\u0000-\u001f\u007f]/.test(value)) export const wireguardInterfaceUpdateSchema = wgPatchInterfaceSchema.extend({ name: text.min(1).max(64).refine(value => value.trim().length > 0).optional(), listenPort: z.number().int().min(1).max(65535).optional(), mtu: z.number().int().min(1).max(65535).optional(), comment: text.optional(), privateKey: wireguardCreateKey.optional() }).strict().refine(value => Object.values(value).some(item => item !== undefined), "Нет полей для изменения") export type WireguardInterfaceUpdate = z.infer export function wireguardInterfaceNativeUpdate(fields: Record) { const mapping: Record = { name: "name", "listen-port": "listenPort", mtu: "mtu", comment: "comment", disabled: "disabled" }, patch: Record = {} for (const [key, value] of Object.entries(fields)) { if (!mapping[key]) throw new McpError("UNSUPPORTED_CAPABILITY", "Поле native WireGuard не поддерживается общим планом", 409) patch[mapping[key]] = key === "disabled" && typeof value === "string" ? observedBoolean(value) ?? value : ["mtu", "listen-port"].includes(key) && typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value } return wireguardInterfaceUpdateSchema.parse(patch) } type State = WireguardInterfaceDeleteState export interface WireguardInterfaceUpdateCommand { method: "PATCH" | "DELETE" | "PUT"; path: string; resource: "interfaces" | "ipv4" | "ipv6"; id?: string; body?: Record } const fail = (code: string, message: string) => new McpError(code, message, code === "INVALID_INPUT" ? 400 : ["STATE_UNAVAILABLE", "MUTATION_OUTCOME_UNKNOWN", "VERIFICATION_FAILED"].includes(code) ? 502 : 409) const genericMirrors = new Set(["mtu", "listen-port", "disabled", "comment", "public-key", "private-key"]) function privateMirrorMatches(observed: string, expected: string | undefined, publicKey: string | undefined) { if (observed === expected) return true return wireguardPrivateScalarsEqual(observed, expected, publicKey) } function genericWireguardConfiguration(state: State) { const result: Record[] = [] for (const parent of state.base.interfaces) { const rows = state.dependencies["/interface"].filter(row => row[".id"] === parent[".id"] || row.name === parent.name) if (rows.length !== 1 || rows[0][".id"] !== parent[".id"] || rows[0].name !== parent.name) throw fail("STATE_CONFLICT", "Расходятся общий и WireGuard каталоги интерфейсов") const generic = rows[0] for (const key of genericMirrors) if (generic[key] !== undefined) { const expected = parent[key] ?? (key === "comment" ? "" : undefined) const equal = key === "private-key" ? privateMirrorMatches(generic[key], expected, parent["public-key"]) : key === "disabled" ? observedBoolean(generic[key]) !== null && observedBoolean(generic[key]) === observedBoolean(expected ?? "") : ["mtu", "listen-port"].includes(key) ? observedInteger(generic[key], 1, 65535) !== null && observedInteger(generic[key], 1, 65535) === observedInteger(expected ?? "", 1, 65535) : expected !== undefined && generic[key] === expected if (!equal) throw fail("STATE_UNAVAILABLE", "Противоречат конфигурационные свойства общего и WireGuard каталогов") } // Mirrors are independently validated against the complete WG rows. Seal every other stable generic property. result.push(Object.fromEntries(Object.entries(generic).filter(([key]) => !genericMirrors.has(key) && !["fp-rx-byte", "fp-tx-byte", "fp-rx-packet", "fp-tx-packet", "rx-drop", "tx-drop", "rx-error", "tx-error", "tx-queue-drop"].includes(key)))) } return greStableRows(wireguardConfigurationRows(result)) } export async function wireguardInterfaceUpdateProof(state: State) { // Normalize a private proof-only clone. Never alter captured source rows, secret references or native command bodies. const normalized = structuredClone(state) for (const row of normalized.base.interfaces) { const scalar = wireguardCorroboratedPrivateScalar(row["private-key"], row["public-key"]) if (scalar !== undefined) row["private-key"] = scalar } return (await privateFingerprinter("wireguard-interface-update-v2"))(fingerprint({ configuration: await wireguardInterfaceDeleteProof(normalized), genericInterfaces: genericWireguardConfiguration(state) })) } export async function readWireguardInterfaceUpdateState(server: ServerRow, id: string, authorize: () => Promise = async () => {}) { const state = await readWireguardInterfaceDeleteState(server, id, authorize) state.proof = await wireguardInterfaceUpdateProof(state) return state } export function planWireguardInterfaceUpdate(state: State, id: string, raw: unknown): WireguardInterfaceUpdateCommand[] { const parsed = wireguardInterfaceUpdateSchema.safeParse(raw) if (!parsed.success) throw fail("INVALID_INPUT", "Некорректные поля изменения WireGuard") const input = parsed.data // Also validates stable identity, ownership, all parent dependencies and child protections. planWireguardInterfaceDelete(state, id) const target = state.base.interfaces.find(row => row[".id"] === id)! if (input.name === "wg-flow" || input.comment === "MikrotikManager traffic-flow overlay") throw fail("PROTECTED_OBJECT", "Имя и комментарий зарезервированы NetFlow") if (input.name && input.name !== target.name) { if (input.address !== undefined) throw fail("STATE_CONFLICT", "Изменяйте имя и адрес WireGuard отдельными операциями") assertWireguardCreateAllowed(state, { serverId: 1, name: input.name, listenPort: 13231, mtu: 1420 }) } const fields: Record = {} for (const [name, key] of [["name", "name"], ["listenPort", "listen-port"], ["mtu", "mtu"], ["comment", "comment"], ["privateKey", "private-key"], ["disabled", "disabled"]] as const) if (input[name] !== undefined) fields[key] = String(input[name]) const commands: WireguardInterfaceUpdateCommand[] = Object.keys(fields).length ? [{ method: "PATCH", path: "/interface/wireguard", resource: "interfaces", id, body: fields }] : [] if (input.address !== undefined) { const belongs = (row: Record) => [target.name, id].includes(row.interface) const all = [...state.ipv4, ...state.ipv6].filter(belongs).sort((a, b) => Number(observedBoolean(a.disabled) === true) - Number(observedBoolean(b.disabled) === true) || a.address.localeCompare(b.address)) const statics = all.filter(row => observedBoolean(row.dynamic) === false) if (statics.some(row => Boolean(row["from-pool"]) || observedBoolean(row["eui-64"]) === true)) throw fail("DEPENDENCY_CONFLICT", "Адрес из IPv6-пула или EUI-64 требует отдельной настройки") const primary = statics[0] const secondary = statics.filter(row => row.address !== primary?.address) const desired = input.address ? interfaceAddressKey(input.address) : null for (const row of statics) if (!secondary.includes(row) && (desired === null || interfaceAddressKey(row.address) !== desired)) commands.push({ method: "DELETE", path: interfaceAddressPath(row.address), resource: interfaceAddressPath(row.address) === "/ip/address" ? "ipv4" : "ipv6", id: row[".id"] }) const retainedPrimary = statics.find(row => !secondary.includes(row) && desired !== null && interfaceAddressKey(row.address) === desired) if (retainedPrimary && (observedBoolean(retainedPrimary.disabled) !== false || interfaceAddressPath(retainedPrimary.address) === "/ipv6/address" && observedBoolean(retainedPrimary.advertise) !== false)) commands.push({ method: "PATCH", path: interfaceAddressPath(retainedPrimary.address), resource: interfaceAddressPath(retainedPrimary.address) === "/ip/address" ? "ipv4" : "ipv6", id: retainedPrimary[".id"], body: { disabled: "false", ...(interfaceAddressPath(retainedPrimary.address) === "/ipv6/address" ? { advertise: "false" } : {}) } }) if (input.address && !statics.some(row => interfaceAddressKey(row.address) === desired)) { // Check literal address collisions and selectors without treating the existing interface as a new object. const check = structuredClone(state); check.base.interfaces = check.base.interfaces.filter(row => row[".id"] !== id); check.dependencies["/interface"] = check.dependencies["/interface"].filter(row => row[".id"] !== id) assertWireguardCreateAllowed(check, { serverId: 1, name: target.name, listenPort: 13231, mtu: 1420, address: input.address }) commands.push({ method: "PUT", path: interfaceAddressPath(input.address), resource: interfaceAddressPath(input.address) === "/ip/address" ? "ipv4" : "ipv6", body: { address: input.address, interface: target.name, disabled: "false", ...(interfaceAddressPath(input.address) === "/ipv6/address" ? { advertise: "false" } : {}) } }) } } return commands } export function projectWireguardInterfaceUpdate(state: State, command: WireguardInterfaceUpdateCommand, createdId?: string) { const next = structuredClone(state), rows = command.resource === "interfaces" ? next.base.interfaces : next[command.resource] if (command.method === "PUT") { if (!createdId) throw fail("STATE_UNAVAILABLE", "Не подтверждён ID нового адреса"); rows.push({ ".id": createdId, dynamic: "false", ...command.body! }); return next } const target = rows.find(row => row[".id"] === command.id) if (!target) throw fail("STATE_CONFLICT", "Объект команды WireGuard исчез") if (command.method === "DELETE") rows.splice(rows.indexOf(target), 1) else { const oldName = target.name const privateKeyObserved = target["private-key"] !== undefined Object.assign(target, command.body) if (command.body?.["private-key"]) { target["public-key"] = wireguardPublicKey(command.body["private-key"]) // Public-key derivation proves the replacement even on sources that omit private material. if (!privateKeyObserved) delete target["private-key"] } if (command.body?.name && command.body.name !== oldName) { for (const row of [...next.base.peers, ...next.ipv4, ...next.ipv6]) if (row.interface === oldName) row.interface = command.body.name const generic = next.dependencies["/interface"].find(row => row[".id"] === command.id); if (generic) generic.name = command.body.name } if (command.resource === "interfaces") { const generic = next.dependencies["/interface"].find(row => row[".id"] === command.id) if (generic) for (const key of genericMirrors) if (generic[key] !== undefined && target[key] !== undefined) generic[key] = target[key] } } return next } export async function updateWireguardInterface(server: ServerRow, id: string, raw: unknown, expectedProof?: string, authorize: () => Promise = async () => {}, options: { recordRevision?: boolean } = {}) { const parsed = wireguardInterfaceUpdateSchema.safeParse(raw) if (!parsed.success) throw fail("INVALID_INPUT", "Некорректные поля изменения WireGuard") return withApplicationMutationLock(() => withConfigMutationLock([server.id], () => executeGuardedApplicationWrite({ kind: "wireguard", id }, [server.id], async () => { const protections = await wireguardCreateProtectionProof(server.id) const source = async () => { await authorize(); const current = await getServerRowById(server.id); if (!current || !sameWireguardEndpoint(current, server) || await wireguardCreateProtectionProof(server.id) !== protections) throw fail("STATE_CONFLICT", "Источник или защиты WireGuard изменились") } let state = await readWireguardInterfaceUpdateState(server, id, source) if (expectedProof && expectedProof !== state.proof) throw fail("STATE_CONFLICT", "WireGuard изменился после подготовки") const commands = planWireguardInterfaceUpdate(state, id, parsed.data), client = MikrotikClient.fromServer(server) let completedCommands = 0 for (const command of commands) { const fresh = await readWireguardInterfaceUpdateState(server, id, source) if (fresh.proof !== state.proof) throw fail(completedCommands ? "VERIFICATION_FAILED" : "STATE_CONFLICT", "WireGuard изменился между командами") const fence = async () => { const current = await readWireguardInterfaceUpdateState(server, id, source); if (current.proof !== fresh.proof) throw fail("STATE_CONFLICT", "WireGuard изменился после native intent"); await source() } await source() try { const path = command.path + (command.id ? "/" + encodeURIComponent(command.id) : ""); if (command.method === "PATCH") await client.patch(path, command.body!, 15000, fence); else if (command.method === "PUT") await client.put(path, command.body!, 15000, fence); else await client.delete(path, 15000, fence) } catch (error) { if (error instanceof McpError) throw error; throw fail("MUTATION_OUTCOME_UNKNOWN", "Исход команды WireGuard неизвестен; повтор запрещён") } let after: State try { after = await readWireguardInterfaceUpdateState(server, id, source) } catch { throw fail("MUTATION_OUTCOME_UNKNOWN", "Команда отправлена, read-back недоступен; повтор запрещён") } try { planWireguardInterfaceDelete(after, id) } catch { throw fail("VERIFICATION_FAILED", "Идентичность или зависимости WireGuard изменились после команды; повтор запрещён") } let projected: State if (command.method === "PUT") { const added = after[command.resource as "ipv4" | "ipv6"].filter(row => !fresh[command.resource as "ipv4" | "ipv6"].some(old => old[".id"] === row[".id"])) if (added.length !== 1 || observedBoolean(added[0].dynamic) !== false || Object.entries(command.body!).some(([key, value]) => key === "address" ? interfaceAddressKey(added[0][key]) !== interfaceAddressKey(value) : ["disabled", "advertise"].includes(key) ? observedBoolean(added[0][key]) !== observedBoolean(value) : added[0][key] !== value && !(key === "interface" && added[0][key] === id))) throw fail("VERIFICATION_FAILED", "Новый адрес WireGuard не подтверждён; повтор запрещён") projected = structuredClone(fresh); projected[command.resource as "ipv4" | "ipv6"].push(added[0]) } else projected = projectWireguardInterfaceUpdate(fresh, command) if (await wireguardInterfaceUpdateProof(projected) !== after.proof) throw fail("VERIFICATION_FAILED", "Изменение WireGuard или сохранность зависимостей не подтверждены; повтор запрещён") state = after; completedCommands++ } let revisionRecorded = false try { if (options.recordRevision !== false) revisionRecorded = await captureAndAppendRevision({ serverId: server.id, section: "wireguard", source: "apply", capture: () => captureWireguardSnapshot(server, source) }) !== null } catch { /* A verified mutation is never replayed for history storage. */ } return { ok: true, verified: true, interfaceId: id, afterProof: state.proof, commandCount: commands.length, completedCommands, revisionRecorded, forwardingVerified: false } }))) }