Files
MikrotikManager/backend/src/services/traffic-flow-protocol-scope.test.ts
T

176 lines
12 KiB
TypeScript

/** Exercise protocol scopes with the actual parser and production receiver bodies.
* The fixture keeps SQL/metadata inert and can use native localhost UDP sockets. */
import assert from "node:assert/strict"
import { test } from "node:test"
import { parseFlowPacket, clearFlowTemplateCache, resetFlowTemplatesForTests, templateCacheUsageForTests, FLOW_TEMPLATE_LIMITS as limits, FlowTemplateRefused } from "./traffic-flow-parse.js"
import { makeIngress, makeWorker } from "./traffic-flow-protocol-scope-fixture.js"
import { createSocket } from "node:dgram"
type Transport = { sourcePort: number; collectorSocketId: string }
const known: Transport = { sourcePort: 2055, collectorSocketId: "owned_socket_a" }
function packet(version: 9 | 10, domain: number, setId: number, body: Buffer) {
const size=version===9?20:16,value=Buffer.alloc(size+4+body.length)
value.writeUInt16BE(version);value.writeUInt16BE(version===9?1:value.length,2)
value.writeUInt32BE(domain,version===9?16:12);value.writeUInt16BE(setId,size);value.writeUInt16BE(body.length+4,size+2);body.copy(value,size+4)
return value
}
function template(version:9|10,domain:number,reverse=false,count=2,id=256){
const body=Buffer.alloc(4+count*4);body.writeUInt16BE(id);body.writeUInt16BE(count,2)
for(let i=0;i<count;i++){body.writeUInt16BE(count===2?(i===0?(reverse?12:8):(reverse?8:12)):1,4+i*4);body.writeUInt16BE(count===2?4:1,6+i*4)}
return packet(version,domain,version===9?0:2,body)
}
const data=(version:9|10,domain:number)=>packet(version,domain,256,Buffer.from([192,0,2,1,198,51,100,1]))
const decode=(version:9|10,domain:number,transport?:Transport)=>parseFlowPacket(data(version,domain),"known",transport)[0]?.src
test("IPFIX observation domains sharing a numeric template ID retain independent field definitions",()=>{
resetFlowTemplatesForTests()
parseFlowPacket(template(10,1),"known",known);parseFlowPacket(template(10,2,true),"known",known)
assert.equal(decode(10,1,known),"192.0.2.1");assert.equal(decode(10,2,known),"198.51.100.1")
assert.equal(templateCacheUsageForTests("known").exporterTemplates,2)
})
test("actual UDP source port scopes templates independently of exporter IP and observation domain",()=>{
resetFlowTemplatesForTests()
const other={...known,sourcePort:2056}
parseFlowPacket(template(10,1),"known",known);parseFlowPacket(template(10,1,true),"known",other)
assert.equal(decode(10,1,known),"192.0.2.1");assert.equal(decode(10,1,other),"198.51.100.1")
})
test("v9 source IDs and protocol versions never borrow each other's templates",()=>{
resetFlowTemplatesForTests()
parseFlowPacket(template(9,7),"known",known);parseFlowPacket(template(9,8,true),"known",known)
parseFlowPacket(template(10,7,true),"known",known)
assert.equal(decode(9,7,known),"192.0.2.1");assert.equal(decode(9,8,known),"198.51.100.1");assert.equal(decode(10,7,known),"198.51.100.1")
})
test("IPFIX IPv6 NAT fields survive ingress without replacing the original addresses", () => {
resetFlowTemplatesForTests()
const ingress = makeIngress()
const fields: [number, Buffer][] = [
[281, Buffer.from("20010db8000200000000000000000001", "hex")],
[282, Buffer.from("20010db8000200000000000000000002", "hex")],
[225, Buffer.alloc(4)], [226, Buffer.alloc(4)],
[27, Buffer.from("20010db8000100000000000000000001", "hex")],
[28, Buffer.from("20010db8000100000000000000000002", "hex")],
[10, Buffer.from([0, 0, 0, 13])], [14, Buffer.from([0, 0, 0, 42])],
[227, Buffer.from([0x14, 0xe9])], [228, Buffer.from([0x01, 0xbb])],
[1, Buffer.from([0, 0, 0x05, 0xdc])], [2, Buffer.from([0, 0, 0, 10])],
]
for (const [index, layout] of [fields, [...fields].reverse()].entries()) {
const body = Buffer.alloc(4 + layout.length * 4)
body.writeUInt16BE(256)
body.writeUInt16BE(layout.length, 2)
layout.forEach(([id, value], offset) => {
body.writeUInt16BE(id, 4 + offset * 4)
body.writeUInt16BE(value.length, 6 + offset * 4)
})
const domain = index + 1
ingress.ingest(packet(10, domain, 2, body), "known", known)
ingress.ingest(packet(10, domain, 256, Buffer.concat(layout.map(([, value]) => value))), "known", known)
}
assert.equal(ingress.queued.length, 2)
for (const flow of ingress.queued) assert.deepEqual(
[flow.src, flow.dst, flow.natSrc, flow.natDst, flow.inIface, flow.outIface, flow.natSrcPort, flow.natDstPort, flow.bytes, flow.packets],
["2001:db8:1:0:0:0:0:1", "2001:db8:1:0:0:0:0:2", "2001:db8:2:0:0:0:0:1", "2001:db8:2:0:0:0:0:2", "13", "42", 5353, 443, 1500, 10],
)
})
test("unknown legacy transport still works in its explicit partition and never borrows known UDP state",()=>{
resetFlowTemplatesForTests()
parseFlowPacket(template(10,0),"known")
assert.equal(decode(10,0),"192.0.2.1");assert.throws(()=>decode(10,0,known),error=>error instanceof FlowTemplateRefused&&error.reason==="missing-template")
parseFlowPacket(template(10,0,true),"known",known)
assert.equal(decode(10,0),"192.0.2.1");assert.equal(decode(10,0,known),"198.51.100.1")
assert.throws(()=>decode(10,0,{...known,collectorSocketId:"replacement_socket"}),error=>error instanceof FlowTemplateRefused&&error.reason==="missing-template")
})
test("invalid context refuses before cache creation, mutation or LRU touch; socket scope width is bounded",()=>{
resetFlowTemplatesForTests()
for(let i=0;i<limits.exporters;i++)parseFlowPacket(template(10,0),"valid-"+i,known)
const before=templateCacheUsageForTests()
for(const invalid of [{...known,sourcePort:0},{...known,sourcePort:65536},{...known,sourcePort:1.5},
{...known,collectorSocketId:""},{...known,collectorSocketId:"a".repeat(129)},{...known,collectorSocketId:"a\0b"}]){
assert.throws(()=>parseFlowPacket(template(10,0),"valid-0",invalid),/transport context/)
assert.throws(()=>parseFlowPacket(template(10,0),"invalid-new",invalid),/transport context/)
}
assert.deepEqual(templateCacheUsageForTests(),before)
parseFlowPacket(template(10,0),"replacement",known)
assert.equal(templateCacheUsageForTests("valid-0").exporterTemplates,0,"invalid access must not refresh valid-0's LRU position")
})
test("template cardinality and fields remain bounded per exporter across all domains and sessions",()=>{
resetFlowTemplatesForTests()
for(let i=0;i<limits.perExporterTemplates;i++)parseFlowPacket(template(10,i),"known",{...known,sourcePort:i+1})
assert.equal(templateCacheUsageForTests("known").exporterTemplates,limits.perExporterTemplates)
assert.throws(()=>parseFlowPacket(template(9,999),"known",known),error=>error instanceof FlowTemplateRefused&&error.reason==="exporter-templates")
resetFlowTemplatesForTests()
for(let i=0;i<limits.perExporterFields/limits.perTemplateFields;i++)parseFlowPacket(template(10,i,false,limits.perTemplateFields),"known",{...known,sourcePort:i+1})
assert.equal(templateCacheUsageForTests("known").exporterFields,limits.perExporterFields)
assert.throws(()=>parseFlowPacket(template(10,999),"known",known),error=>error instanceof FlowTemplateRefused&&error.reason==="exporter-fields")
})
test("receiver-owned socket identity and actual rinfo.port reach parser through real Worker/engine bodies",async()=>{
resetFlowTemplatesForTests()
const ingress=makeIngress(),worker=makeWorker(ingress)
const payload={listenHost:"127.0.0.1",listenPort:2055,topN:20,retentionHours:24,exporterMap:{}}
await worker.start(payload)
const first=worker.sockets[0]
first.emitPacket(template(10,1),10001);first.emitPacket(template(10,1,true),10002)
first.emitPacket(data(10,1),10001);first.emitPacket(data(10,1),10002)
assert.equal(ingress.queued[0].src,"192.0.2.1");assert.equal(ingress.queued[1].src,"198.51.100.1")
assert.equal(worker.contexts[0].sourcePort,10001);assert.equal(worker.contexts[1].sourcePort,10002)
const previousSocketId=worker.contexts[0].collectorSocketId
await worker.start(payload)
const second=worker.sockets[1]
first.emitPacket(template(10,1,true),10001)
second.emitPacket(data(10,1),10001)
assert.equal(ingress.queued.length,2,"replacement socket cannot reuse old templates and retired socket cannot populate new scope")
const replacementContext=worker.contexts.at(-1)
assert(replacementContext)
assert.notEqual(replacementContext.collectorSocketId,previousSocketId)
second.emitPacket(template(10,1),10001);second.emitPacket(data(10,1),10001)
assert.equal(ingress.queued.length,3);assert.equal(ingress.queued[2].src,"192.0.2.1")
const before=templateCacheUsageForTests()
assert.equal(ingress.ingest(template(10,99),"unmapped",known),false)
assert.deepEqual(templateCacheUsageForTests(),before,"wire domain must not bypass mapped-exporter authorization")
})
test("real localhost UDP source ports reach the production Worker callback and stay isolated through engine parsing",async()=>{
resetFlowTemplatesForTests()
const ingress=makeIngress(),worker=makeWorker(ingress,true),senders=[createSocket("udp4"),createSocket("udp4")]
try{
await Promise.all(senders.map(socket=>new Promise<void>((resolve,reject)=>{socket.once("error",reject);socket.bind(0,"127.0.0.1",resolve)})))
await worker.start({listenHost:"127.0.0.1",listenPort:0,topN:20,retentionHours:24,exporterMap:{}})
const receiver=worker.sockets[0]
await new Promise<void>((resolve,reject)=>{receiver.once("error",reject);try{receiver.address();resolve()}catch{receiver.once("listening",resolve)}})
const destination=receiver.address().port
const send=(index:number,bytes:Buffer)=>new Promise<void>((resolve,reject)=>senders[index].send(bytes,destination,"127.0.0.1",error=>error?reject(error):resolve()))
await send(0,template(10,1));await worker.waitForContexts(1)
await send(1,template(10,1,true));await worker.waitForContexts(2)
await send(0,data(10,1));await worker.waitForContexts(3)
await send(1,data(10,1));await worker.waitForContexts(4)
assert.equal(worker.contexts[0].sourcePort,senders[0].address().port)
assert.equal(worker.contexts[1].sourcePort,senders[1].address().port)
assert.notEqual(worker.contexts[0].sourcePort,worker.contexts[1].sourcePort)
assert.equal(ingress.queued[0].src,"192.0.2.1");assert.equal(ingress.queued[1].src,"198.51.100.1")
}finally{
for(const socket of [...senders,...worker.sockets])await new Promise<void>(resolve=>{try{socket.close(resolve)}catch{resolve()}})
}
})
test("production cache clear preserves refusal counters and repeated receiver incarnations cannot exhaust exporter capacity",async()=>{
resetFlowTemplatesForTests()
assert.throws(()=>parseFlowPacket(template(10,1,false,limits.perTemplateFields+1),"known"),FlowTemplateRefused)
const refused=templateCacheUsageForTests().refusedTemplates
clearFlowTemplateCache();assert.equal(templateCacheUsageForTests().refusedTemplates,refused)
const ingress=makeIngress(),worker=makeWorker(ingress)
const payload={listenHost:"127.0.0.1",listenPort:2055,topN:20,retentionHours:24,exporterMap:{}}
for(let i=0;i<limits.perExporterTemplates+2;i++){
await worker.start(payload)
const current=worker.sockets.at(-1)!
current.emitPacket(data(10,1),2055)
assert.equal(ingress.queued.length,i,"fresh receiver must wait for a template")
assert.equal(templateCacheUsageForTests().refusedTemplates,refused+i+1,"each fresh receiver exposes exactly one missing-template refusal")
current.emitPacket(template(10,1),2055);current.emitPacket(data(10,1),2055)
assert.equal(templateCacheUsageForTests("known").exporterTemplates,1)
assert.equal(templateCacheUsageForTests().refusedTemplates,refused+i+1,"accepted refresh/data do not erase prior refusal history")
}
assert.equal(ingress.queued.length,limits.perExporterTemplates+2,"decoded queued records survive parser-cache retirement")
assert.equal(ingress.queued[0].src,"192.0.2.1")
resetFlowTemplatesForTests();assert.equal(templateCacheUsageForTests().refusedTemplates,0)
})