56 lines
5.4 KiB
TypeScript
56 lines
5.4 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { fileURLToPath } from "node:url"
|
|
import { wireguardPeerCreateSchema, wireguardPeerCreateBody, wireguardPeerCreateStages, assertWireguardPeerCreateAllowed, wireguardPeerCreatePrefix, wireguardPeerCreatePreserved } from "./wireguard-peer-create.js"
|
|
import { wireguardPublicKey } from "./wireguard-interface-create.js"
|
|
import { wireguardInterfaceDeleteProof, wireguardInterfaceDependencyPaths, type WireguardInterfaceDeleteState } from "./wireguard-interface-delete.js"
|
|
|
|
export async function acceptWireguardPeerCreateModel() {
|
|
const key = Buffer.alloc(32, 61).toString("base64"), publicKey = wireguardPublicKey(key)
|
|
const input = wireguardPeerCreateSchema.parse({ serverId: 112, interfaceName: "wg-parent", publicKey, allowedAddresses: ["192.0.2.2/32", "2001:db8::2/128"], endpointAddress: "vpn.example.org", endpointPort: 65535, persistentKeepalive: 60, name: "owned", comment: "peer", privateKey: key, clientAddress: "192.0.2.2,2001:db8::2", clientDns: "1.1.1.1", clientEndpoint: "client.example.org" })
|
|
const state: WireguardInterfaceDeleteState = { base: { interfaces: [{ ".id": "*a", name: input.interfaceName, disabled: "false", opaque: "NEVER_PARENT" }], peers: [{ ".id": "*f", interface: input.interfaceName, "public-key": "foreign", disabled: "false", opaque: "NEVER_FOREIGN" }], bindings: [], flow: { hostPublicKey: "", registered: false }, serverProof: "source", proof: "base" }, ipv4: [], ipv6: [], dependencies: Object.fromEntries(wireguardInterfaceDependencyPaths.map(path => [path, []])), filters: [], proof: "" }
|
|
state.dependencies["/interface"] = [{ ".id": "*a", name: input.interfaceName, type: "wg" }]
|
|
state.base.bindings.push({ id: "user", interfaceName: input.interfaceName, peerPublicKey: "foreign" })
|
|
state.dependencies["/routing/ospf/interface-template"].push({ ".id": "*o", interfaces: input.interfaceName, networks: "2001:db8::/64" })
|
|
state.dependencies["/ip/vrf"].push({ ".id": "*v", name: "owned", interfaces: input.interfaceName })
|
|
state.ipv6.push({ ".id": "*ip", interface: input.interfaceName, address: "2001:db8::1/64", dynamic: "false", disabled: "false" })
|
|
state.proof = await wireguardInterfaceDeleteProof(state)
|
|
assertWireguardPeerCreateAllowed(state, input)
|
|
assert.deepEqual(wireguardPeerCreateStages(input), ["peer", "peer-enable"])
|
|
const after = structuredClone(state)
|
|
const row = { ".id": "*c", ...wireguardPeerCreateBody(input), interface: "*a", "persistent-keepalive": "1m", opaque: "native-default" }
|
|
after.base.peers.push(row)
|
|
assert.equal(await wireguardPeerCreatePrefix(after, input, state.proof, 1), true)
|
|
const enabled = structuredClone(after); enabled.base.peers[1].disabled = "no"
|
|
assert.equal(await wireguardPeerCreatePrefix(enabled, input, state.proof, 2, "*c"), true)
|
|
assert.equal(wireguardPeerCreatePreserved(after, enabled, "*c"), true)
|
|
for (const change of [
|
|
(s: typeof enabled) => { s.base.interfaces[0].opaque = "changed" },
|
|
(s: typeof enabled) => { s.base.peers[0].opaque = "changed" },
|
|
(s: typeof enabled) => { s.base.peers[1]["client-address"] = "lost" },
|
|
(s: typeof enabled) => { s.base.peers[1]["private-key"] = "lost" },
|
|
(s: typeof enabled) => { s.base.peers[1][".id"] = "*new" },
|
|
(s: typeof enabled) => { s.base.peers[1].interface = "foreign" },
|
|
(s: typeof enabled) => { s.base.peers[1].dynamic = "unknown" },
|
|
(s: typeof enabled) => { s.dependencies["/ip/firewall/filter"].push({ ".id": "*d", opaque: "new" }) },
|
|
(s: typeof enabled) => { s.base.peers.push({ ...s.base.peers[1], ".id": "*e" }) },
|
|
]) { const changed = structuredClone(enabled); change(changed); assert.equal(await wireguardPeerCreatePrefix(changed, input, state.proof, 2, "*c"), false) }
|
|
enabled.base.peers[1].opaque = "changed native default"
|
|
assert.equal(wireguardPeerCreatePreserved(after, enabled, "*c"), false)
|
|
for (const change of [
|
|
(s: typeof state) => { s.dependencies["/interface"][0][".id"] = "*wrong" },
|
|
(s: typeof state) => { s.base.interfaces[0].dynamic = "unknown" },
|
|
(s: typeof state) => { s.base.interfaces[0].name = "wg-flow" },
|
|
(s: typeof state) => { s.base.interfaces[0].comment = "MikrotikManager traffic-flow overlay" },
|
|
(s: typeof state) => { s.base.peers[0]["public-key"] = publicKey },
|
|
]) { const changed = structuredClone(state); change(changed); assert.throws(() => assertWireguardPeerCreateAllowed(changed, input)) }
|
|
for (const privateKey of ["none", "auto", undefined]) {
|
|
const request = wireguardPeerCreateSchema.parse({ ...input, privateKey, disabled: true }), next = structuredClone(state)
|
|
next.base.peers.push({ ".id": "*c", ...wireguardPeerCreateBody(request), ...(privateKey === "auto" ? { "private-key": key } : {}) })
|
|
assert.equal(await wireguardPeerCreatePrefix(next, request, state.proof, 1), true)
|
|
assert.deepEqual(wireguardPeerCreateStages(request), ["peer"])
|
|
}
|
|
for (const invalid of [{ publicKey: "bad" }, { allowedAddresses: ["bad"] }, { endpointPort: 65536 }, { persistentKeepalive: -1 }, { privateKey: "secret" }, { interfaceName: "\0" }]) assert.equal(wireguardPeerCreateSchema.safeParse({ ...input, ...invalid }).success, false)
|
|
console.log("WireGuard peer create model: full fields, IPv4/IPv6, key modes, parent/foreign/opaque preservation, stable identity, supported existing users/OSPF/VRF closure and NetFlow guards")
|
|
}
|
|
if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) await acceptWireguardPeerCreateModel()
|