518 lines
17 KiB
TypeScript
518 lines
17 KiB
TypeScript
import { assert } from "chai";
|
|
|
|
import { parseInput, Request, questionParser, headerParser } from "./request"
|
|
import { IMessageHeader, RecordTypes } from "./types";
|
|
import { RDATARecord, RecourceRecord } from "./record";
|
|
import { Question } from "./question";
|
|
import { Header } from "./header";
|
|
|
|
function fromHex(data: string) {
|
|
return Buffer.from(data.replace(/\s/g, ""), "hex");
|
|
}
|
|
|
|
describe("parser", function () {
|
|
describe("header", function () {
|
|
describe("header parser", function () {
|
|
let should_templ: IMessageHeader = {
|
|
ID: 0, QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0, RA: 0, Z: 0, AD: 0, CD: 0, RCODE: 0, QDCOUNT: 0, ANCOUNT: 0, ARCOUNT: 0, NSCOUNT: 0
|
|
}
|
|
|
|
let tests: { name: string, data: string, fields: Partial<IMessageHeader> }[] = [
|
|
{
|
|
name: "Testing ID field",
|
|
data: "0001 0000 0000 0000 0000 0000",
|
|
fields: {
|
|
ID: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing ID field with max value",
|
|
data: "FFFF 0000 0000 0000 0000 0000",
|
|
fields: {
|
|
ID: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Testing QR field",
|
|
data: "0000 8000 0000 0000 0000 0000",
|
|
fields: {
|
|
QR: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing OPCODE field value 2",
|
|
data: "0000 1000 0000 0000 0000 0000",
|
|
fields: {
|
|
OPCODE: 2
|
|
}
|
|
},
|
|
{
|
|
name: "Testing OPCODE field value 1",
|
|
data: "0000 0800 0000 0000 0000 0000",
|
|
fields: {
|
|
OPCODE: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing AA field",
|
|
data: "0000 0400 0000 0000 0000 0000",
|
|
fields: {
|
|
AA: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing TC field",
|
|
data: "0000 0200 0000 0000 0000 0000",
|
|
fields: {
|
|
TC: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing RD field",
|
|
data: "0000 0100 0000 0000 0000 0000",
|
|
fields: {
|
|
RD: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Testing RCODE field",
|
|
data: "0000 0002 0000 0000 0000 0000",
|
|
fields: {
|
|
RCODE: 2
|
|
}
|
|
},
|
|
{
|
|
name: "Testing QDCOUNT field max value",
|
|
data: "0000 0000 FFFF 0000 0000 0000",
|
|
fields: {
|
|
QDCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Testing ANCOUNT field max value",
|
|
data: "0000 0000 0000 FFFF 0000 0000",
|
|
fields: {
|
|
ANCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Testing NSCOUNT field max value",
|
|
data: "0000 0000 0000 0000 FFFF 0000",
|
|
fields: {
|
|
NSCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Testing ARCOUNT field max value",
|
|
data: "0000 0000 0000 0000 0000 FFFF",
|
|
fields: {
|
|
ARCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Testing all Flags and Values max",
|
|
data: "FFFF FFFF FFFF FFFF FFFF FFFF",
|
|
fields: {
|
|
ID: 65535, QR: 1, OPCODE: 15, AA: 1, TC: 1, RD: 1, RA: 1, Z: 1, AD: 1, CD: 1, RCODE: 15, QDCOUNT: 65535, ANCOUNT: 65535, NSCOUNT: 65535, ARCOUNT: 65535
|
|
}
|
|
}
|
|
]
|
|
tests.forEach(function (e) {
|
|
it(e.name, function () {
|
|
let testdata = fromHex(e.data)
|
|
let should: IMessageHeader = { ...should_templ, ...e.fields }
|
|
let header = <any>headerParser.parse(testdata);
|
|
assert.hasAllKeys(header, Object.keys(should), "Parsed header is missing some fields")
|
|
assert.deepEqual(header, should, "Parsed header has not expected values!")
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("header serializer", function () {
|
|
let empty_header: IMessageHeader = {
|
|
ID: 0, QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0, RA: 0, Z: 0, AD: 0, CD: 0, RCODE: 0, QDCOUNT: 0, ANCOUNT: 0, ARCOUNT: 0, NSCOUNT: 0
|
|
}
|
|
let tests: { name: string, result: string, values: Partial<IMessageHeader> }[] = [
|
|
{
|
|
name: "Fill header with 0s",
|
|
result: "0000 0000 0000 0000 0000 0000",
|
|
values: {}
|
|
},
|
|
{
|
|
name: "Set header id to 5",
|
|
result: "0005 0000 0000 0000 0000 0000",
|
|
values: {
|
|
ID: 5
|
|
}
|
|
},
|
|
{
|
|
name: "Set QR",
|
|
result: "0000 8000 0000 0000 0000 0000",
|
|
values: {
|
|
QR: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set OPCODE",
|
|
result: "0000 7800 0000 0000 0000 0000",
|
|
values: {
|
|
OPCODE: 15
|
|
}
|
|
},
|
|
{
|
|
name: "Set AA",
|
|
result: "0000 0400 0000 0000 0000 0000",
|
|
values: {
|
|
AA: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set TC",
|
|
result: "0000 0200 0000 0000 0000 0000",
|
|
values: {
|
|
TC: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set RD",
|
|
result: "0000 0100 0000 0000 0000 0000",
|
|
values: {
|
|
RD: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set RA",
|
|
result: "0000 0080 0000 0000 0000 0000",
|
|
values: {
|
|
RA: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set Z",
|
|
result: "0000 0040 0000 0000 0000 0000",
|
|
values: {
|
|
Z: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set AD",
|
|
result: "0000 0020 0000 0000 0000 0000",
|
|
values: {
|
|
AD: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set CD",
|
|
result: "0000 0010 0000 0000 0000 0000",
|
|
values: {
|
|
CD: 1
|
|
}
|
|
},
|
|
{
|
|
name: "Set RCODE",
|
|
result: "0000 000F 0000 0000 0000 0000",
|
|
values: {
|
|
RCODE: 15
|
|
}
|
|
},
|
|
{
|
|
name: "Set QDCOUNT",
|
|
result: "0000 0000 FFFF 0000 0000 0000",
|
|
values: {
|
|
QDCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Set ANCOUNT",
|
|
result: "0000 0000 0000 FFFF 0000 0000",
|
|
values: {
|
|
ANCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Set NSCOUNT",
|
|
result: "0000 0000 0000 0000 FFFF 0000",
|
|
values: {
|
|
NSCOUNT: 65535
|
|
}
|
|
},
|
|
{
|
|
name: "Set ARCOUNT",
|
|
result: "0000 0000 0000 0000 0000 FFFF",
|
|
values: {
|
|
ARCOUNT: 65535
|
|
}
|
|
},
|
|
]
|
|
|
|
tests.forEach(function (e) {
|
|
it(e.name, function () {
|
|
let header = Object.assign({}, empty_header, e.values)
|
|
let slz = new Header(header).lock();
|
|
assert.equal(slz.length, 12, "Header returns wrong length");
|
|
let res = Buffer.alloc(slz.length);
|
|
assert.equal(slz.serialize(res, 0), 12, "Header returns wrong offset");
|
|
assert.equal(res.toString("hex"), e.result.replace(/\s/g, "").toLowerCase(), "Header serialization failed");
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("question", function () {
|
|
let questionData = fromHex("0474 6573 7407 6578 616d 706c 6503 636f 6d00 0001 0001")
|
|
let questionObj = {
|
|
QNAME: "test.example.com",
|
|
QTYPE: RecordTypes.A,
|
|
QCLASS: 1
|
|
}
|
|
it("check question parser with one question", function () {
|
|
|
|
let res = questionParser.parse(questionData)
|
|
|
|
assert.deepEqual(res, questionObj, "Question parser does not parse input correctly")
|
|
})
|
|
|
|
it("check question serialization", function () {
|
|
let slz = new Question(questionObj).lock()
|
|
assert.equal(slz.length, 22, "Question serializer returns wrong length")
|
|
let res = Buffer.alloc(slz.length);
|
|
assert.equal(slz.serialize(res, 0), 22, "Question serializer returns wrong offset")
|
|
assert.equal(res.toString("hex"), questionData.toString("hex"), "Query serializer does not serialite correctly");
|
|
})
|
|
})
|
|
|
|
it("parse valid request", () => {
|
|
let should = {
|
|
header: { ID: 59445, QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 1, RA: 0, Z: 0, AD: 0, CD: 0, RCODE: 0, QDCOUNT: 1, ANCOUNT: 0, NSCOUNT: 0, ARCOUNT: 0 },
|
|
questions: [{ QNAME: 'example.com', QTYPE: 1, QCLASS: 1 }]
|
|
}
|
|
let data = fromHex("E835 0100 0001 0000 0000 0000 07 6578616D706c65 03636F6D 00 0001 0001");
|
|
let res = parseInput(data);
|
|
assert.deepEqual(res, should);
|
|
})
|
|
|
|
|
|
it("recource record serialization", function () {
|
|
let should = "07 6578616D706C65 03 636f6D 00 0001 0001 00000640 0004 0A000001"
|
|
let rr = new RDATARecord()
|
|
rr.CLASS = 1
|
|
rr.NAME = "example.com"
|
|
rr.TTL = 1600
|
|
rr.TYPE = 1
|
|
rr.RDATA = fromHex("0A 00 00 01")
|
|
let srl = rr.lock();
|
|
let res = Buffer.alloc(srl.length);
|
|
srl.serialize(res, 0);
|
|
assert.equal(res.toString("hex"), should.replace(/\s/g, "").toLowerCase(), "Serialization not working properly")
|
|
})
|
|
|
|
it("recource record constructor value assign", function () {
|
|
let should = "07 6578616D706C65 03 636f6D 00 0001 0001 00000640 0004 0A000001"
|
|
let rr = new RDATARecord({
|
|
CLASS: 1,
|
|
NAME: "example.com",
|
|
TTL: 1600,
|
|
TYPE: 1,
|
|
RDATA: fromHex("0A 00 00 01")
|
|
})
|
|
let srl = rr.lock();
|
|
assert.equal(srl.length, 27, "Record serializer returns wrong length")
|
|
let res = Buffer.alloc(srl.length);
|
|
assert.equal(srl.serialize(res, 0), 27, "Record serializer returns wrong offset")
|
|
assert.equal(res.toString("hex"), should.replace(/\s/g, "").toLowerCase(), "Record serialization not working properly")
|
|
})
|
|
|
|
it("full response serialization", function () {
|
|
let reqData = fromHex("E835 0100 0001 0000 0000 0000 07 6578616D706c65 03636F6D 00 0001 0001");
|
|
let should = "E835 8580 0001000100000000 076578616D706C6503636F6D0000010001 07 6578616D706C65 03 636F6D 00 0001 0001 0000 0640 0004 0A000001"
|
|
let request = new Request(reqData, "")
|
|
let rr = new RDATARecord()
|
|
rr.CLASS = 1
|
|
rr.NAME = "example.com"
|
|
rr.TTL = 1600
|
|
rr.TYPE = 1
|
|
rr.RDATA = fromHex("0A 00 00 01")
|
|
request.addAnswer(rr);
|
|
let data = request.serialize()
|
|
assert.equal(data.toString("hex"), should.replace(/\s/g, "").toLowerCase(), "Whole packet serialization failed")
|
|
})
|
|
})
|
|
|
|
import { DnsCore, StoragePlugin, Record, MonitoringPlugin, QuestionPlugin, AnswerHandler, ListenerPlugin } from "./core"
|
|
|
|
describe("DNS Core", function () {
|
|
it("Initialization", () => {
|
|
let core = new DnsCore();
|
|
assert.exists(core, "Core constructor working")
|
|
})
|
|
|
|
it("Adding fake plugins and initialize", () => {
|
|
let core = new DnsCore();
|
|
|
|
core.addListener({
|
|
init: async (c) => { assert.exists(c, "Core not defined on Plugin init") },
|
|
Priority: 0,
|
|
registerCallback: () => { }
|
|
})
|
|
|
|
core.addMonitoring({
|
|
init: async (c) => { assert.exists(c, "Core not defined on Plugin init") },
|
|
Priority: 0,
|
|
onRequest: () => { }
|
|
})
|
|
|
|
core.addQuestion({
|
|
init: async (c) => { assert.exists(c, "Core not defined on Plugin init") },
|
|
QuestionTypes: [RecordTypes.A],
|
|
Priority: 0,
|
|
handleQuestion: async () => { },
|
|
})
|
|
|
|
core.addStorage({
|
|
getAllRecordsForDomain: async () => undefined,
|
|
getRecords: async () => undefined,
|
|
init: async (c) => { assert.exists(c, "Core not defined on Plugin init") },
|
|
isResponsible: () => true,
|
|
NoCache: false,
|
|
Priority: 0,
|
|
RecordTypes: [RecordTypes.A]
|
|
})
|
|
|
|
return core.start();
|
|
})
|
|
|
|
it("Test Request flow", async function () {
|
|
let core = new DnsCore();
|
|
|
|
let listener = new TestListenerPlugin();
|
|
core.addListener(listener)
|
|
|
|
let monitoring = new TestMonitoringPlugin({
|
|
domain: "example.com",
|
|
hostname: "test",
|
|
type: "A"
|
|
});
|
|
core.addMonitoring(monitoring)
|
|
|
|
|
|
let question = new TestQuestionPlugin();
|
|
core.addQuestion(question)
|
|
|
|
let storage = new TestStoragePlugin({
|
|
domain: "example.com",
|
|
hostname: "test",
|
|
type: RecordTypes.A,
|
|
ttl: 500,
|
|
value: "10.0.0.1"
|
|
})
|
|
core.addStorage(storage);
|
|
|
|
await core.start();
|
|
|
|
let reqData = fromHex("E835 0100 0001 0000 0000 0000 04 74657374 07 6578616D706c65 03 636F6D 00 0001 0001");
|
|
let should = "E835 8580 0001000100000000 04 74657374 076578616D706C6503636F6D0000010001 04 74657374 07 6578616D706C65 03 636F6D 00 0001 0001 0000 0640 0004 0A000001"
|
|
let resData = await listener.sendRequest(reqData)
|
|
|
|
assert.equal(resData.toString("hex"), should.replace(/\s/g, "").toLowerCase(), "Whole packet serialization failed")
|
|
})
|
|
})
|
|
|
|
class TestStoragePlugin implements StoragePlugin {
|
|
re: Record = { domain: "example.com", hostname: "test", type: RecordTypes.A, value: "10.0.0.1", ttl: 1600 }
|
|
|
|
constructor(record?: Record) {
|
|
if (record)
|
|
this.re = record;
|
|
}
|
|
|
|
Priority = 0
|
|
NoCache = false
|
|
RecordTypes = [RecordTypes.A]
|
|
isResponsible(domain: string) {
|
|
// console.log("Is responsible")
|
|
return true
|
|
}
|
|
|
|
async init(core) { assert.exists(core, "TestStoragePlugin init no core object") }
|
|
|
|
async getRecords(domain, hostname, type) {
|
|
if (domain !== this.re.domain || hostname !== this.re.hostname || type != this.re.type) return undefined;
|
|
return [this.re];
|
|
}
|
|
|
|
async getAllRecordsForDomain(domain) {
|
|
if (domain !== this.re.domain) return undefined;
|
|
return [this.re];
|
|
}
|
|
}
|
|
|
|
class TestMonitoringPlugin implements MonitoringPlugin {
|
|
constructor(private should: { domain: string, hostname: string, type: string }) { }
|
|
|
|
async init(core) { assert.exists(core, "TestMonitoringPlugin init no core object") }
|
|
Priority = 0
|
|
onRequest(domain, hostname, type) {
|
|
assert.equal(this.should.domain, domain, "Domain value wrong")
|
|
assert.equal(this.should.hostname, hostname, "Domain value wrong")
|
|
assert.equal(this.should.type, type, "Domain value wrong")
|
|
}
|
|
}
|
|
|
|
class ARR extends RecourceRecord {
|
|
TYPE = RecordTypes.A
|
|
|
|
constructor(domain: string, ip: string) {
|
|
super();
|
|
this.NAME = domain
|
|
this.TTL = 1600
|
|
let data = Buffer.alloc(4)
|
|
let idx = 0;
|
|
ip.split(".").forEach(e => {
|
|
data.writeUInt8(Number(e), idx);
|
|
idx++;
|
|
})
|
|
this.dataLock = () => {
|
|
return {
|
|
length: 4,
|
|
serialize: (buffer, offset) => {
|
|
data.copy(buffer, offset);
|
|
return offset + 4;
|
|
}
|
|
}
|
|
};
|
|
// this.RDATA = data;
|
|
}
|
|
}
|
|
|
|
class TestQuestionPlugin implements QuestionPlugin {
|
|
private Core: DnsCore
|
|
QuestionTypes = [RecordTypes.A]
|
|
Priority = 0
|
|
async init(core) {
|
|
assert.exists(core, "TestQuestionPlugin init no core object")
|
|
this.Core = core;
|
|
}
|
|
|
|
async handleQuestion(question: Question, request: AnswerHandler, next: () => void) {
|
|
assert(this.QuestionTypes.find(e => e === <any>question.QTYPE), "Handler was called with not supported questin type")
|
|
let parts = question.QNAME.split(".")
|
|
let domain = parts.splice(-2, 2).join(".")
|
|
let hostname = parts.join(".");
|
|
hostname = hostname !== "" ? hostname : "*"
|
|
let records = await this.Core.storageManager.getRecords(domain, hostname, question.QTYPE)
|
|
records.forEach(e => request.addAnswer(new ARR(question.QNAME, e.value)));
|
|
}
|
|
}
|
|
|
|
class TestListenerPlugin implements ListenerPlugin {
|
|
async init(core) { assert.exists(core, "TestListenerPlugin init no core object") }
|
|
Priority = 0;
|
|
callback: (data: Buffer, sender: string, max_size?: number) => Promise<Buffer>;
|
|
registerCallback(callback) {
|
|
this.callback = callback;
|
|
}
|
|
|
|
sendRequest(message: Buffer) {
|
|
return this.callback(message, "localhost")
|
|
}
|
|
} |