Files
MikrotikManager/backend/src/services/server-connection-test.test.ts
T

70 lines
5.6 KiB
TypeScript

import assert from "node:assert/strict"
import test from "node:test"
import http, { createServer } from "node:http"
import https from "node:https"
import { performServerConnectionTest } from "./server-connection-test.js"
import { isAllowedServerConnectionAddress, serverConnectionActionSchema, serverConnectionSecretPurpose } from "../modules/mcp/server-connection-actions.js"
import { isAllowedServerConnectionAddress as pureAddressPolicy, serverConnectionHostSchema } from "../modules/mcp/server-connection-destination-policy.js"
test("connection schema refuses raw passwords and binds the full endpoint", () => {
assert.equal(isAllowedServerConnectionAddress, pureAddressPolicy)
assert.equal(serverConnectionActionSchema.shape.host, serverConnectionHostSchema)
const endpoint = { host:"router.example",port:443,useSsl:true,verifySsl:true,apiPath:"/rest",username:"admin" }
const purpose = serverConnectionSecretPurpose(endpoint)
for (const patch of [{host:"else.example"},{port:80},{useSsl:false},{verifySsl:false},{apiPath:"/api"},{username:"other"}]) assert.notEqual(serverConnectionSecretPurpose({...endpoint,...patch}),purpose)
const reference = "00000000-0000-4000-8000-000000000001"
for (const patch of [{password:"plaintext"},{host:"http://router.example"},{apiPath:"//else"},{apiPath:"/rest/../secret"},{username:"a:b"},{port:65536}]) assert.equal(serverConnectionActionSchema.safeParse({...endpoint,passwordRef:reference,...patch}).success,false)
for (const ip of ["0.0.0.0","169.254.169.254","224.0.0.1","255.255.255.255","100.100.100.200","::","fe80::1","ff02::1","::ffff:a9fe:a9fe","64:ff9b::a9fe:a9fe"]) assert.equal(isAllowedServerConnectionAddress(ip),false,ip)
for (const ip of ["127.0.0.1","10.0.0.1","192.168.88.1","::1","fd00::1"]) assert.equal(isAllowedServerConnectionAddress(ip),true,ip)
})
test("bounded shared test pins both GETs, retains Host/SNI, refuses redirect, sanitizes reflection and fences publication", async () => {
let mode = "ok", requests = 0, dns = 0, before = 0, after = 0
const seen: string[] = [], optionsSeen: https.RequestOptions[] = []
const secret = "NEVER_TEST_PASSWORD"
const server = createServer((request,response) => {
requests++; seen.push(request.headers.host ?? ""); assert.equal(request.method,"GET")
assert.equal(request.headers.authorization,"Basic "+Buffer.from(`admin:${secret}`).toString("base64"))
response.setHeader("content-type","application/json")
if (mode === "redirect") { response.statusCode=302; response.setHeader("location","http://169.254.169.254/"); response.end("{}"); return }
if (mode === "oversized") { response.end(" ".repeat(65537)); return }
if (mode === "malformed") { response.end(`{${secret}`); return }
if (mode === "lost") { request.socket.destroy(); return }
if (request.url === "/rest/system/identity") response.end(JSON.stringify({name:"fixture-"+secret}))
else { assert.equal(request.url,"/rest/system/resource"); response.end(JSON.stringify([{version:"7.22", "board-name":"fixture",uptime:"1h","total-memory":"128MiB"},{version:"wrong","board-name":"small",uptime:"0","total-memory":"1MiB"}])) }
})
await new Promise<void>(resolve => server.listen(0,"127.0.0.1",resolve))
const port = (server.address() as {port:number}).port
const original = https.request
// Capture real TLS options but route this isolated fixture through plain loopback
// HTTP; DNS lookup is still consumed by Node's actual request path twice.
https.request = ((options: https.RequestOptions, callback: (res: http.IncomingMessage)=>void) => { optionsSeen.push(options); return http.request({...options,agent:false},callback) }) as typeof https.request
const params = {host:"router.fixture.invalid",port,useSsl:true,verifySsl:true,apiPath:"/rest",username:"admin",password:secret,servername:"router.fixture.invalid",lookup: ((_host: string, opts: {all?:boolean}, callback:(...args:unknown[])=>void) => {dns++; if(opts.all)callback(null,[{address:"127.0.0.1",family:4}]);else callback(null,"127.0.0.1",4)}) as typeof import("node:dns").lookup}
const fences = {beforeDispatch:async()=>{before++},afterDispatch:async()=>{after++}}
try {
const result = await performServerConnectionTest(params,fences)
assert.equal(result.success,true); assert.equal(result.version,"7.22"); assert.equal(result.identity,"fixture-[redacted]")
assert.equal(requests,2); assert.equal(dns,2); assert.equal(before,2); assert.equal(after,1)
assert.deepEqual(seen,[`router.fixture.invalid:${port}`,`router.fixture.invalid:${port}`])
for (const options of optionsSeen) { assert.equal(options.servername,"router.fixture.invalid"); assert.equal(options.rejectUnauthorized,true) }
for (const fault of ["redirect","oversized","malformed","lost"]) {
mode=fault; const count=requests
const result=await performServerConnectionTest(params,fences)
assert.equal(result.success,false); assert.equal(result.outcome,fault==="redirect"?"rejected":"unknown")
assert.ok(!JSON.stringify(result).includes(secret)); assert.equal(requests,count+2)
}
const count=requests
await assert.rejects(performServerConnectionTest(params,{beforeDispatch:async()=>{throw Error("revoked")}}),/revoked/)
assert.equal(requests,count)
mode="ok"
await assert.rejects(performServerConnectionTest(params,{afterDispatch:async()=>{throw Error("source drift")}}),/source drift/)
assert.equal(requests,count+2)
const controller=new AbortController();controller.abort()
await assert.rejects(performServerConnectionTest(params,{signal:controller.signal}),/Aborted/)
assert.equal(requests,count+2)
} finally { https.request=original; await new Promise<void>(resolve=>server.close(()=>resolve())) }
})