@gajanan_107/dns3 1.0.0

package/index.js

@@ -0,0 +1,17 @@
+const { createServer }             = require("./server/udpServer");
+const { parseRequest,
+        parseResponse }            = require("./packet/parser");
+const { createResponseFromRequest} = require("./resolver/index");
+const { upstreamResponse }         = require("./resolver/forwarder");
+const { getRecord,
+        registerRecord }           = require("./packet/records");
+
+module.exports = {
+    createServer,
+    parseRequest,
+    parseResponse,
+    createResponseFromRequest,
+    upstreamResponse,
+    getRecord,
+    registerRecord,
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@gajanan_107/dns3",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/packet/encoder.js

@@ -0,0 +1,89 @@
+const { buildHeader } = require("./header");
+const { encodeName }  = require("./nameCodec");
+const { getRecord }   = require("./records");
+
+function buildFlagsRaw(flags) {
+    return  ((flags.qr     & 0x1) << 15) |
+            ((flags.opcode & 0xF) << 11) |
+            ((flags.aa     & 0x1) << 10) |
+            ((flags.tc     & 0x1) << 9)  |
+            ((flags.rd     & 0x1) << 8)  |
+            ((flags.ra     & 0x1) << 7)  |
+            ((flags.z      & 0x1) << 6)  |
+             (flags.rcode  & 0xF);
+}
+
+function resolveHandler(type, context) {
+    const handler = getRecord(type);
+    if (!handler) throw new Error(`${context}: no handler registered for DNS type "${type}"`);
+    return handler;
+}
+
+function encodeResponse(response) {
+    if (!response || typeof response.id !== "number") {
+        throw new Error("encodeResponse: response must be an object with an id — use createResponseFromRequest()");
+    }
+    if (!Array.isArray(response.questions) || response.questions.length === 0) {
+        throw new Error("encodeResponse: response must have at least one question");
+    }
+    if (!Array.isArray(response.answers)) {
+        throw new Error("encodeResponse: response.answers must be an array");
+    }
+
+    const flagsRaw = (response.flags && typeof response.flags === "object")
+        ? buildFlagsRaw(response.flags)
+        : (response.flags || 0x8180);
+
+    const header = buildHeader({
+        id:      response.id,
+        flags:   flagsRaw,
+        qdcount: response.questions.length,
+        ancount: response.answers.length,
+    });
+
+    const questionBuffers = response.questions.map((q) => {
+        const handler  = resolveHandler(q.type, "encodeResponse question");
+        const name     = encodeName(q.name);
+        const typeBuf  = Buffer.alloc(2); typeBuf.writeUInt16BE(handler.typeCode);
+        const clsBuf   = Buffer.alloc(2); clsBuf.writeUInt16BE(q.class);
+        return Buffer.concat([name, typeBuf, clsBuf]);
+    });
+
+    const q = response.questions[0];
+
+    const answerBuffers = response.answers.flatMap((entry, index) => {
+        const isFullRecord = entry !== null &&
+                             typeof entry === "object" &&
+                             typeof entry.type === "string" &&
+                             entry.data !== undefined;
+
+        const record = isFullRecord ? entry : {
+            name:  q.name,
+            type:  q.type,
+            class: q.class,
+            ttl:   300,
+            data:  entry,
+        };
+
+        if (!record.name || !record.type || record.data === undefined) {
+            throw new Error(`encodeResponse: answers[${index}] could not be resolved — push a data value or a full { name, type, class, ttl, data } record`);
+        }
+
+        const handler = resolveHandler(record.type, `encodeResponse answers[${index}]`);
+        const entries = Array.isArray(record.data) && handler.typeCode !== 16 ? record.data : [record.data];
+
+        return entries.map((value) => {
+            const rdata    = handler.encode(value);
+            const nameBuf  = encodeName(record.name);
+            const typeBuf  = Buffer.alloc(2); typeBuf.writeUInt16BE(handler.typeCode);
+            const clsBuf   = Buffer.alloc(2); clsBuf.writeUInt16BE(record.class || 1);
+            const ttlBuf   = Buffer.alloc(4); ttlBuf.writeUInt32BE(record.ttl || 300);
+            const rdlength = Buffer.alloc(2); rdlength.writeUInt16BE(rdata.length);
+            return Buffer.concat([nameBuf, typeBuf, clsBuf, ttlBuf, rdlength, rdata]);
+        });
+    });
+
+    return Buffer.concat([header, ...questionBuffers, ...answerBuffers]);
+}
+
+module.exports = { encodeResponse };

package/packet/header.js

@@ -0,0 +1,34 @@
+function parseHeader(buffer) {
+    return {
+        id: buffer.readUInt16BE(0),
+
+        flags: buffer.readUInt16BE(2),
+
+        qdcount: buffer.readUInt16BE(4),
+        ancount: buffer.readUInt16BE(6),
+        nscount: buffer.readUInt16BE(8),
+        arcount: buffer.readUInt16BE(10),
+    };
+}
+
+function buildHeader({
+    id,
+    flags = 0x8180, 
+    qdcount = 1,
+    ancount = 1,
+    nscount = 0,
+    arcount = 0
+}) {
+    const buf = Buffer.alloc(12);
+
+    buf.writeUInt16BE(id, 0);
+    buf.writeUInt16BE(flags, 2);
+    buf.writeUInt16BE(qdcount, 4);
+    buf.writeUInt16BE(ancount, 6);
+    buf.writeUInt16BE(nscount, 8);
+    buf.writeUInt16BE(arcount, 10);
+
+    return buf;
+}
+
+module.exports = { parseHeader, buildHeader };

package/packet/nameCodec.js

@@ -0,0 +1,47 @@
+
+function encodeName(name) {
+    const buffers = [];
+
+    for (const part of name.split(".")) {
+        const len = Buffer.alloc(1);
+        len.writeUInt8(part.length);
+        buffers.push(len);
+        buffers.push(Buffer.from(part, "ascii"));
+    }
+
+    buffers.push(Buffer.from([0x00]));
+    return Buffer.concat(buffers);
+}
+
+function parseName(buffer, offset) {
+    const labels = [];
+    let jumped = false;
+    let originalOffset = offset;
+
+    while (true) {
+        const len = buffer[offset];
+
+        if ((len & 0xC0) === 0xC0) {
+            const pointer = ((len & 0x3F) << 8) | buffer[offset + 1];
+            if (!jumped) originalOffset = offset + 2;
+            offset = pointer;
+            jumped = true;
+            continue;
+        }
+
+        if (len === 0) {
+            offset += 1;
+            break;
+        }
+
+        labels.push(buffer.toString("ascii", offset + 1, offset + 1 + len));
+        offset += len + 1;
+    }
+
+    return {
+        name:   labels.join("."),
+        offset: jumped ? originalOffset : offset,
+    };
+}
+
+module.exports = { encodeName, parseName };

package/packet/parser.js

@@ -0,0 +1,96 @@
+const { parseHeader } = require("./header");
+const { parseName }   = require("./nameCodec");
+const { getRecord }   = require("./records");
+
+function parseFlags(raw) {
+    return {
+        raw,
+        qr:     (raw >> 15) & 0x1,
+        opcode: (raw >> 11) & 0xF,
+        aa:     (raw >> 10) & 0x1,
+        tc:     (raw >> 9)  & 0x1,
+        rd:     (raw >> 8)  & 0x1,
+        ra:     (raw >> 7)  & 0x1,
+        z:      (raw >> 6)  & 0x1,
+        rcode:  raw         & 0xF,
+    };
+}
+
+function resolveType(numericType) {
+    const handler = getRecord(numericType);
+    return handler ? handler.typeName : String(numericType);
+}
+
+function readQuestions(buffer, offset, count) {
+    const questions = [];
+    for (let i = 0; i < count; i++) {
+        if (offset >= buffer.length) throw new Error("parser: buffer ended while reading questions");
+        const { name, offset: after } = parseName(buffer, offset);
+        offset = after;
+        if (offset + 4 > buffer.length) throw new Error("parser: buffer too short for question type/class");
+        questions.push({
+            name,
+            type:  resolveType(buffer.readUInt16BE(offset)),
+            class: buffer.readUInt16BE(offset + 2),
+        });
+        offset += 4;
+    }
+    return { questions, offset };
+}
+
+function readRecords(buffer, offset, count) {
+    const records = [];
+    for (let i = 0; i < count; i++) {
+        if (offset >= buffer.length) break;
+        const { name, offset: after } = parseName(buffer, offset);
+        offset = after;
+        if (offset + 10 > buffer.length) throw new Error("parser: buffer too short for resource record");
+        const numericType = buffer.readUInt16BE(offset);
+        const cls         = buffer.readUInt16BE(offset + 2);
+        const ttl         = buffer.readUInt32BE(offset + 4);
+        const rdlength    = buffer.readUInt16BE(offset + 8);
+        offset += 10;
+        if (offset + rdlength > buffer.length) throw new Error("parser: buffer too short for rdata");
+        const handler = getRecord(numericType);
+        const data    = handler ? handler.decode(buffer, offset, rdlength) : buffer.slice(offset, offset + rdlength);
+        offset += rdlength;
+        records.push({ name, type: resolveType(numericType), class: cls, ttl, data });
+    }
+    return { records, offset };
+}
+
+function parseRequest(buffer) {
+    if (!Buffer.isBuffer(buffer)) throw new Error("parseRequest: expected a raw Buffer");
+    const header = parseHeader(buffer);
+    const { questions,          offset: o1 } = readQuestions(buffer, 12, header.qdcount);
+    const { records: answers,   offset: o2 } = readRecords(buffer, o1, header.ancount);
+    const { records: authority, offset: o3 } = readRecords(buffer, o2, header.nscount);
+    const { records: additional             } = readRecords(buffer, o3, header.arcount);
+    return {
+        id:         header.id,
+        flags:      parseFlags(header.flags),
+        questions,
+        answers,
+        authority,
+        additional,
+    };
+}
+
+function parseResponse(buffer) {
+    if (!Buffer.isBuffer(buffer)) throw new Error("parseResponse: expected a raw Buffer");
+    const header = parseHeader(buffer);
+    const { questions,          offset: o1 } = readQuestions(buffer, 12, header.qdcount);
+    const { records: answers,   offset: o2 } = readRecords(buffer, o1, header.ancount);
+    const { records: authority, offset: o3 } = readRecords(buffer, o2, header.nscount);
+    const { records: additional             } = readRecords(buffer, o3, header.arcount);
+    return {
+        id:         header.id,
+        flags:      parseFlags(header.flags),
+        questions,
+        answers,
+        authority,
+        additional,
+    };
+}
+
+module.exports = { parseRequest, parseResponse };

package/packet/records/index.js

@@ -0,0 +1,147 @@
+const { encodeName, parseName } = require("../nameCodec");
+
+const registry = new Map();
+
+const types = [
+    {
+        typeCode: 1, typeName: "A",
+        encode(ip) {
+            const octets = ip.split(".").map(Number);
+            if (octets.length !== 4 || octets.some((o) => isNaN(o) || o < 0 || o > 255)) {
+                throw new Error(`A record: invalid IPv4 address "${ip}"`);
+            }
+            return Buffer.from(octets);
+        },
+        decode(buf, offset) {
+            if (offset + 4 > buf.length) throw new Error("A record: buffer too short");
+            return `${buf[offset]}.${buf[offset+1]}.${buf[offset+2]}.${buf[offset+3]}`;
+        },
+    },
+    {
+        typeCode: 2, typeName: "NS",
+        encode(ns)           { return encodeName(ns); },
+        decode(buf, offset)  { return parseName(buf, offset).name; },
+    },
+    {
+        typeCode: 5, typeName: "CNAME",
+        encode(cname)        { return encodeName(cname); },
+        decode(buf, offset)  { return parseName(buf, offset).name; },
+    },
+    {
+        typeCode: 6, typeName: "SOA",
+        encode({ mname, rname, serial, refresh, retry, expire, minimum }) {
+            for (const [k, v] of Object.entries({ mname, rname, serial, refresh, retry, expire, minimum })) {
+                if (v === undefined || v === null) throw new Error(`SOA record: missing field "${k}"`);
+            }
+            const nums = Buffer.alloc(20);
+            nums.writeUInt32BE(serial,  0);
+            nums.writeUInt32BE(refresh, 4);
+            nums.writeUInt32BE(retry,   8);
+            nums.writeUInt32BE(expire,  12);
+            nums.writeUInt32BE(minimum, 16);
+            return Buffer.concat([encodeName(mname), encodeName(rname), nums]);
+        },
+        decode(buf, offset) {
+            const { name: mname, offset: o1 } = parseName(buf, offset);
+            const { name: rname, offset: o2 } = parseName(buf, o1);
+            if (o2 + 20 > buf.length) throw new Error("SOA record: buffer too short");
+            return {
+                mname, rname,
+                serial:  buf.readUInt32BE(o2),
+                refresh: buf.readUInt32BE(o2 + 4),
+                retry:   buf.readUInt32BE(o2 + 8),
+                expire:  buf.readUInt32BE(o2 + 12),
+                minimum: buf.readUInt32BE(o2 + 16),
+            };
+        },
+    },
+    {
+        typeCode: 12, typeName: "PTR",
+        encode(hostname)     { return encodeName(hostname); },
+        decode(buf, offset)  { return parseName(buf, offset).name; },
+    },
+    {
+        typeCode: 15, typeName: "MX",
+        encode({ priority, exchange }) {
+            if (typeof priority !== "number") throw new Error("MX record: priority must be a number");
+            if (typeof exchange !== "string") throw new Error("MX record: exchange must be a string");
+            const prio = Buffer.alloc(2);
+            prio.writeUInt16BE(priority);
+            return Buffer.concat([prio, encodeName(exchange)]);
+        },
+        decode(buf, offset) {
+            if (offset + 2 > buf.length) throw new Error("MX record: buffer too short");
+            const priority = buf.readUInt16BE(offset);
+            const { name: exchange } = parseName(buf, offset + 2);
+            return { priority, exchange };
+        },
+    },
+    {
+        typeCode: 16, typeName: "TXT",
+        encode(value) {
+            const strings = Array.isArray(value) ? value : [value];
+            return Buffer.concat(strings.map((s) => {
+                const content = Buffer.from(s, "ascii");
+                if (content.length > 255) throw new Error(`TXT record: string exceeds 255 bytes: "${s}"`);
+                const len = Buffer.alloc(1);
+                len.writeUInt8(content.length);
+                return Buffer.concat([len, content]);
+            }));
+        },
+        decode(buf, offset, rdlength) {
+            if (typeof rdlength !== "number") throw new Error("TXT record: rdlength required for decode");
+            const strings = [];
+            const end = offset + rdlength;
+            while (offset < end) {
+                const len = buf[offset++];
+                strings.push(buf.toString("ascii", offset, offset + len));
+                offset += len;
+            }
+            return strings.length === 1 ? strings[0] : strings;
+        },
+    },
+    {
+        typeCode: 28, typeName: "AAAA",
+        encode(ip6) {
+            const halves = ip6.split("::");
+            if (halves.length > 2) throw new Error(`AAAA record: invalid IPv6 address "${ip6}"`);
+            const parseGroups = (s) => s ? s.split(":").map((h) => parseInt(h || "0", 16)) : [];
+            const left  = parseGroups(halves[0]);
+            const right = halves.length === 2 ? parseGroups(halves[1]) : [];
+            const zeros = new Array(8 - left.length - right.length).fill(0);
+            const groups = [...left, ...zeros, ...right];
+            if (groups.length !== 8) throw new Error(`AAAA record: invalid IPv6 address "${ip6}"`);
+            const buf = Buffer.alloc(16);
+            groups.forEach((g, i) => buf.writeUInt16BE(g, i * 2));
+            return buf;
+        },
+        decode(buf, offset) {
+            if (offset + 16 > buf.length) throw new Error("AAAA record: buffer too short");
+            const groups = [];
+            for (let i = 0; i < 8; i++) {
+                groups.push(buf.readUInt16BE(offset + i * 2).toString(16));
+            }
+            return groups.join(":");
+        },
+    },
+];
+
+for (const handler of types) {
+    registry.set(handler.typeCode, handler);
+    registry.set(handler.typeName.toUpperCase(), handler);
+}
+
+function getRecord(typeOrName) {
+    const key = typeof typeOrName === "string" ? typeOrName.toUpperCase() : typeOrName;
+    return registry.get(key) || null;
+}
+
+function registerRecord(handler) {
+    if (!handler.typeCode || !handler.typeName || typeof handler.encode !== "function" || typeof handler.decode !== "function") {
+        throw new Error("registerRecord: handler must have typeCode, typeName, encode(), and decode()");
+    }
+    registry.set(handler.typeCode, handler);
+    registry.set(handler.typeName.toUpperCase(), handler);
+}
+
+module.exports = { getRecord, registerRecord };

package/resolver/forwarder.js

@@ -0,0 +1,37 @@
+const dgram = require("node:dgram");
+
+function upstreamResponse(rawBuffer, upstream = "8.8.8.8", port = 53, timeout = 2000) {
+    if (!Buffer.isBuffer(rawBuffer)) {
+        throw new Error("upstreamResponse: expected a raw Buffer — pass request._raw or the original msg");
+    }
+
+    return new Promise((resolve, reject) => {
+        const client  = dgram.createSocket("udp4");
+        let settled   = false;
+
+        function settle(fn, value) {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            client.close(() => fn(value));
+        }
+
+        const timer = setTimeout(() => {
+            settle(reject, new Error(`upstreamResponse: no reply from ${upstream}:${port} within ${timeout}ms`));
+        }, timeout);
+
+        client.on("error", (err) => {
+            settle(reject, new Error(`upstreamResponse: socket error — ${err.message}`));
+        });
+
+        client.on("message", (msg) => {
+            settle(resolve, msg);
+        });
+
+        client.send(rawBuffer, port, upstream, (err) => {
+            if (err) settle(reject, new Error(`upstreamResponse: failed to send — ${err.message}`));
+        });
+    });
+}
+
+module.exports = { upstreamResponse };

package/resolver/index.js

@@ -0,0 +1,25 @@
+function createResponseFromRequest(request) {
+    if (!request || typeof request.id !== "number") {
+        throw new Error("createResponseFromRequest: pass the object returned by parseRequest()");
+    }
+    if (!Array.isArray(request.questions) || request.questions.length === 0) {
+        throw new Error("createResponseFromRequest: request has no questions");
+    }
+    return {
+        id:        request.id,
+        flags: {
+            qr:     1,
+            opcode: request.flags.opcode,
+            aa:     0,
+            tc:     0,
+            rd:     request.flags.rd,
+            ra:     1,
+            z:      0,
+            rcode:  0,
+        },
+        questions: request.questions.map((q) => ({ ...q })),
+        answers:   [],
+    };
+}
+
+module.exports = { createResponseFromRequest };

package/server/udpServer.js

@@ -0,0 +1,70 @@
+const dgram = require("node:dgram");
+const { encodeResponse } = require("../packet/encoder");
+
+function createServer() {
+    const socket   = dgram.createSocket("udp4");
+    const handlers = {};
+
+    socket.on("message", (msg, rinfo) => {
+        const handler = handlers["onmessage"];
+        if (!handler) return;
+
+        function send(response) {
+            let buffer;
+
+            if (Buffer.isBuffer(response)) {
+                buffer = response;
+            } else {
+                buffer = encodeResponse(response);
+            }
+
+            socket.send(buffer, rinfo.port, rinfo.address, (err) => {
+                if (err) {
+                    const errHandler = handlers["onerror"];
+                    if (errHandler) errHandler(new Error(`send failed: ${err.message}`), rinfo);
+                    else console.error("[dns3] send error:", err.message);
+                }
+            });
+        }
+
+        Promise.resolve()
+            .then(() => handler(msg, send))
+            .catch((err) => {
+                const errHandler = handlers["onerror"];
+                if (errHandler) errHandler(err, rinfo);
+                else console.error("[dns3] unhandled error:", err.message);
+            });
+    });
+
+    socket.on("error", (err) => {
+        const errHandler = handlers["onerror"];
+        if (errHandler) errHandler(err, null);
+        else console.error("[dns3] socket error:", err.message);
+        socket.close();
+    });
+
+    return {
+        handle(event, fn) {
+            const key = event.toLowerCase().replace(/^on/, "on");
+            const allowed = ["onmessage", "onerror"];
+            if (!allowed.includes(key)) {
+                throw new Error(`handle: unknown event "${event}" — supported events: onmessage, onerror`);
+            }
+            if (typeof fn !== "function") {
+                throw new Error(`handle: handler for "${event}" must be a function`);
+            }
+            handlers[key] = fn;
+        },
+
+        listen(port = 5353) {
+            if (typeof port !== "number" || port < 1 || port > 65535) {
+                throw new Error("listen: port must be a number between 1 and 65535");
+            }
+            socket.bind(port, () => {
+                console.log(`[dns3] listening on port ${port}`);
+            });
+        },
+    };
+}
+
+module.exports = { createServer };