@push.rocks/smartdns 5.0.4 → 6.2.0

package/dist_ts_server/classes.dnsserver.js

@@ -0,0 +1,342 @@
+import * as plugins from './plugins.js';
+import { DnsSec } from './classes.dnssec.js';
+import * as dnsPacket from 'dns-packet';
+export class DnsServer {
+    constructor(options) {
+        this.options = options;
+        this.handlers = [];
+        // Initialize DNSSEC
+        this.dnsSec = new DnsSec({
+            zone: options.dnssecZone,
+            algorithm: 'ECDSA', // You can change this based on your needs
+            keySize: 256,
+            days: 365,
+        });
+        // Generate DNSKEY and DS records
+        const { dsRecord, dnskeyRecord } = this.dnsSec.getDsAndKeyPair();
+        // Parse DNSKEY record into dns-packet format
+        this.dnskeyRecord = this.parseDNSKEYRecord(dnskeyRecord);
+        this.keyTag = this.computeKeyTag(this.dnskeyRecord);
+    }
+    registerHandler(domainPattern, recordTypes, handler) {
+        this.handlers.push({ domainPattern, recordTypes, handler });
+    }
+    processDnsRequest(request) {
+        const response = {
+            type: 'response',
+            id: request.id,
+            flags: dnsPacket.AUTHORITATIVE_ANSWER |
+                dnsPacket.RECURSION_AVAILABLE |
+                (request.flags & dnsPacket.RECURSION_DESIRED ? dnsPacket.RECURSION_DESIRED : 0),
+            questions: request.questions,
+            answers: [],
+            additionals: [],
+        };
+        const dnssecRequested = this.isDnssecRequested(request);
+        for (const question of request.questions) {
+            console.log(`Query for ${question.name} of type ${question.type}`);
+            let answered = false;
+            // Handle DNSKEY queries if DNSSEC is requested
+            if (dnssecRequested && question.type === 'DNSKEY' && question.name === this.options.dnssecZone) {
+                const dnskeyAnswer = {
+                    name: question.name,
+                    type: 'DNSKEY',
+                    class: 'IN',
+                    ttl: 3600,
+                    data: this.dnskeyRecord,
+                };
+                response.answers.push(dnskeyAnswer);
+                // Sign the DNSKEY RRset
+                const rrsig = this.generateRRSIG('DNSKEY', [dnskeyAnswer], question.name);
+                response.answers.push(rrsig);
+                answered = true;
+                continue;
+            }
+            for (const handlerEntry of this.handlers) {
+                if (plugins.minimatch.minimatch(question.name, handlerEntry.domainPattern) &&
+                    handlerEntry.recordTypes.includes(question.type)) {
+                    const answer = handlerEntry.handler(question);
+                    if (answer) {
+                        // Ensure the answer has ttl and class
+                        const dnsAnswer = {
+                            ...answer,
+                            ttl: answer.ttl || 300,
+                            class: answer.class || 'IN',
+                        };
+                        response.answers.push(dnsAnswer);
+                        if (dnssecRequested) {
+                            // Sign the answer RRset
+                            const rrsig = this.generateRRSIG(question.type, [dnsAnswer], question.name);
+                            response.answers.push(rrsig);
+                        }
+                        answered = true;
+                        break;
+                    }
+                }
+            }
+            if (!answered) {
+                console.log(`No handler found for ${question.name} of type ${question.type}`);
+                response.flags |= dnsPacket.AUTHORITATIVE_ANSWER;
+                const soaAnswer = {
+                    name: question.name,
+                    type: 'SOA',
+                    class: 'IN',
+                    ttl: 3600,
+                    data: {
+                        mname: `ns1.${this.options.dnssecZone}`,
+                        rname: `hostmaster.${this.options.dnssecZone}`,
+                        serial: Math.floor(Date.now() / 1000),
+                        refresh: 3600,
+                        retry: 600,
+                        expire: 604800,
+                        minimum: 86400,
+                    },
+                };
+                response.answers.push(soaAnswer);
+            }
+        }
+        return response;
+    }
+    isDnssecRequested(request) {
+        if (!request.additionals)
+            return false;
+        for (const additional of request.additionals) {
+            if (additional.type === 'OPT' && typeof additional.flags === 'number') {
+                // The DO bit is the 15th bit (0x8000)
+                if (additional.flags & 0x8000) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    generateRRSIG(type, rrset, name) {
+        // Prepare RRSIG data
+        const algorithm = this.dnsSec.getAlgorithmNumber();
+        const keyTag = this.keyTag;
+        const signerName = this.options.dnssecZone.endsWith('.') ? this.options.dnssecZone : `${this.options.dnssecZone}.`;
+        const inception = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
+        const expiration = inception + 86400; // Valid for 1 day
+        const ttl = rrset[0].ttl || 300;
+        // Serialize the RRset in canonical form
+        const rrsetBuffer = this.serializeRRset(rrset);
+        // Sign the RRset
+        const signature = this.dnsSec.signData(rrsetBuffer);
+        // Construct the RRSIG record
+        const rrsig = {
+            name,
+            type: 'RRSIG',
+            class: 'IN',
+            ttl,
+            data: {
+                typeCovered: type, // Changed to type string
+                algorithm,
+                labels: name.split('.').length - 1,
+                originalTTL: ttl,
+                expiration,
+                inception,
+                keyTag,
+                signerName,
+                signature: signature,
+            },
+        };
+        return rrsig;
+    }
+    serializeRRset(rrset) {
+        // Implement canonical DNS RRset serialization as per RFC 4034 Section 6
+        const buffers = [];
+        for (const rr of rrset) {
+            if (rr.type === 'OPT') {
+                continue; // Skip OPT records
+            }
+            const name = rr.name.endsWith('.') ? rr.name : rr.name + '.';
+            const nameBuffer = this.nameToBuffer(name.toLowerCase());
+            const typeValue = this.qtypeToNumber(rr.type);
+            const typeBuffer = Buffer.alloc(2);
+            typeBuffer.writeUInt16BE(typeValue, 0);
+            const classValue = this.classToNumber(rr.class);
+            const classBuffer = Buffer.alloc(2);
+            classBuffer.writeUInt16BE(classValue, 0);
+            const ttlValue = rr.ttl || 300;
+            const ttlBuffer = Buffer.alloc(4);
+            ttlBuffer.writeUInt32BE(ttlValue, 0);
+            // Serialize the data based on the record type
+            const dataBuffer = this.serializeRData(rr.type, rr.data);
+            const rdLengthBuffer = Buffer.alloc(2);
+            rdLengthBuffer.writeUInt16BE(dataBuffer.length, 0);
+            buffers.push(Buffer.concat([nameBuffer, typeBuffer, classBuffer, ttlBuffer, rdLengthBuffer, dataBuffer]));
+        }
+        return Buffer.concat(buffers);
+    }
+    serializeRData(type, data) {
+        // Implement serialization for each record type you support
+        switch (type) {
+            case 'A':
+                return Buffer.from(data.split('.').map((octet) => parseInt(octet, 10)));
+            case 'AAAA':
+                // Handle IPv6 addresses
+                return Buffer.from(data.split(':').flatMap((segment) => {
+                    const num = parseInt(segment, 16);
+                    return [num >> 8, num & 0xff];
+                }));
+            case 'DNSKEY':
+                const dnskeyData = data;
+                return Buffer.concat([
+                    Buffer.from([dnskeyData.flags >> 8, dnskeyData.flags & 0xff]),
+                    Buffer.from([3]), // Protocol field, always 3
+                    Buffer.from([dnskeyData.algorithm]),
+                    dnskeyData.key,
+                ]);
+            case 'SOA':
+                // Implement SOA record serialization if needed
+                // For now, return an empty buffer or handle as needed
+                return Buffer.alloc(0);
+            // Add cases for other record types as needed
+            default:
+                throw new Error(`Serialization for record type ${type} is not implemented.`);
+        }
+    }
+    parseDNSKEYRecord(dnskeyRecord) {
+        // Parse the DNSKEY record string into dns-packet format
+        const parts = dnskeyRecord.trim().split(/\s+/);
+        const flags = parseInt(parts[3], 10);
+        const algorithm = parseInt(parts[5], 10);
+        const publicKeyBase64 = parts.slice(6).join('');
+        const key = Buffer.from(publicKeyBase64, 'base64');
+        return {
+            flags,
+            algorithm,
+            key,
+        };
+    }
+    computeKeyTag(dnskeyRecord) {
+        // Compute key tag as per RFC 4034 Appendix B
+        const flags = dnskeyRecord.flags;
+        const algorithm = dnskeyRecord.algorithm;
+        const key = dnskeyRecord.key;
+        const dnskeyRdata = Buffer.concat([
+            Buffer.from([flags >> 8, flags & 0xff]),
+            Buffer.from([3]), // Protocol field, always 3
+            Buffer.from([algorithm]),
+            key,
+        ]);
+        let acc = 0;
+        for (let i = 0; i < dnskeyRdata.length; i++) {
+            acc += (i & 1) ? dnskeyRdata[i] : dnskeyRdata[i] << 8;
+        }
+        acc += (acc >> 16) & 0xffff;
+        return acc & 0xffff;
+    }
+    handleHttpsRequest(req, res) {
+        if (req.method === 'POST' && req.url === '/dns-query') {
+            let body = [];
+            req.on('data', (chunk) => {
+                body.push(chunk);
+            }).on('end', () => {
+                const msg = Buffer.concat(body);
+                const request = dnsPacket.decode(msg);
+                const response = this.processDnsRequest(request);
+                const responseData = dnsPacket.encode(response);
+                res.writeHead(200, { 'Content-Type': 'application/dns-message' });
+                res.end(responseData);
+            });
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    }
+    async start() {
+        this.httpsServer = plugins.https.createServer({
+            key: this.options.httpsKey,
+            cert: this.options.httpsCert,
+        }, this.handleHttpsRequest.bind(this));
+        this.udpServer = plugins.dgram.createSocket('udp4');
+        this.udpServer.on('message', (msg, rinfo) => {
+            const request = dnsPacket.decode(msg);
+            const response = this.processDnsRequest(request);
+            const responseData = dnsPacket.encode(response);
+            this.udpServer.send(responseData, rinfo.port, rinfo.address);
+        });
+        this.udpServer.on('error', (err) => {
+            console.error(`UDP Server error:\n${err.stack}`);
+            this.udpServer.close();
+        });
+        const udpListeningDeferred = plugins.smartpromise.defer();
+        const httpsListeningDeferred = plugins.smartpromise.defer();
+        try {
+            this.udpServer.bind(this.options.udpPort, '0.0.0.0', () => {
+                console.log(`UDP DNS server running on port ${this.options.udpPort}`);
+                udpListeningDeferred.resolve();
+            });
+            this.httpsServer.listen(this.options.httpsPort, () => {
+                console.log(`HTTPS DNS server running on port ${this.options.httpsPort}`);
+                httpsListeningDeferred.resolve();
+            });
+        }
+        catch (err) {
+            console.error('Error starting DNS server:', err);
+            process.exit(1);
+        }
+        await Promise.all([udpListeningDeferred.promise, httpsListeningDeferred.promise]);
+    }
+    async stop() {
+        const doneUdp = plugins.smartpromise.defer();
+        const doneHttps = plugins.smartpromise.defer();
+        this.udpServer.close(() => {
+            console.log('UDP DNS server stopped');
+            this.udpServer.unref();
+            this.udpServer = null;
+            doneUdp.resolve();
+        });
+        this.httpsServer.close(() => {
+            console.log('HTTPS DNS server stopped');
+            this.httpsServer.unref();
+            this.httpsServer = null;
+            doneHttps.resolve();
+        });
+        await Promise.all([doneUdp.promise, doneHttps.promise]);
+    }
+    // Helper methods
+    qtypeToNumber(type) {
+        const QTYPE_NUMBERS = {
+            'A': 1,
+            'NS': 2,
+            'CNAME': 5,
+            'SOA': 6,
+            'PTR': 12,
+            'MX': 15,
+            'TXT': 16,
+            'AAAA': 28,
+            'SRV': 33,
+            'DNSKEY': 48,
+            'RRSIG': 46,
+            // Add more as needed
+        };
+        return QTYPE_NUMBERS[type.toUpperCase()] || 0;
+    }
+    classToNumber(cls) {
+        const CLASS_NUMBERS = {
+            'IN': 1,
+            'CH': 3,
+            'HS': 4,
+            // Add more as needed
+        };
+        if (typeof cls === 'number') {
+            return cls;
+        }
+        return CLASS_NUMBERS[cls.toUpperCase()] || 1;
+    }
+    nameToBuffer(name) {
+        const labels = name.split('.');
+        const buffers = labels.map(label => {
+            const len = Buffer.byteLength(label, 'utf8');
+            const buf = Buffer.alloc(1 + len);
+            buf.writeUInt8(len, 0);
+            buf.write(label, 1);
+            return buf;
+        });
+        return Buffer.concat([...buffers, Buffer.from([0])]); // Add root label
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}

package/dist_ts_server/classes.dnstools.d.ts

@@ -0,0 +1,31 @@
+interface DnssecZone {
+    zone: string;
+    algorithm: 'ECDSA' | 'ED25519' | 'RSA';
+    keySize: number;
+    days: number;
+}
+interface DnssecKeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export declare class DnsSec {
+    private zone;
+    private keyPair;
+    private ec?;
+    private eddsa?;
+    constructor(zone: DnssecZone);
+    private generateKeyPair;
+    private getAlgorithmNumber;
+    signData(data: Buffer): Buffer;
+    private generateDNSKEY;
+    private computeKeyTag;
+    private getDNSKEYRecord;
+    getDSRecord(): string;
+    getKeyPair(): DnssecKeyPair;
+    getDsAndKeyPair(): {
+        keyPair: DnssecKeyPair;
+        dsRecord: string;
+        dnskeyRecord: string;
+    };
+}
+export {};

package/dist_ts_server/classes.dnstools.js

@@ -0,0 +1,139 @@
+// Import necessary plugins from plugins.ts
+import * as plugins from './plugins.js';
+export class DnsSec {
+    constructor(zone) {
+        this.zone = zone;
+        // Initialize the appropriate cryptographic instance based on the algorithm
+        switch (this.zone.algorithm) {
+            case 'ECDSA':
+                this.ec = new plugins.elliptic.ec('p256'); // Use P-256 curve for ECDSA
+                break;
+            case 'ED25519':
+                this.eddsa = new plugins.elliptic.eddsa('ed25519');
+                break;
+            case 'RSA':
+                // RSA implementation would go here
+                throw new Error('RSA algorithm is not yet implemented.');
+            default:
+                throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
+        }
+        // Generate the key pair
+        this.keyPair = this.generateKeyPair();
+    }
+    generateKeyPair() {
+        let privateKey;
+        let publicKey;
+        switch (this.zone.algorithm) {
+            case 'ECDSA':
+                if (!this.ec)
+                    throw new Error('EC instance is not initialized.');
+                const ecKeyPair = this.ec.genKeyPair();
+                privateKey = ecKeyPair.getPrivate('hex');
+                publicKey = ecKeyPair.getPublic(false, 'hex'); // Uncompressed format
+                break;
+            case 'ED25519':
+                if (!this.eddsa)
+                    throw new Error('EdDSA instance is not initialized.');
+                const secret = plugins.crypto.randomBytes(32);
+                const edKeyPair = this.eddsa.keyFromSecret(secret);
+                privateKey = edKeyPair.getSecret('hex');
+                publicKey = edKeyPair.getPublic('hex');
+                break;
+            case 'RSA':
+                // RSA key generation would be implemented here
+                throw new Error('RSA key generation is not yet implemented.');
+            default:
+                throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
+        }
+        return { privateKey, publicKey };
+    }
+    getAlgorithmNumber() {
+        switch (this.zone.algorithm) {
+            case 'ECDSA':
+                return 13; // ECDSAP256SHA256
+            case 'ED25519':
+                return 15;
+            case 'RSA':
+                return 8; // RSASHA256
+            default:
+                throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
+        }
+    }
+    signData(data) {
+        // Sign the data using the private key
+        const keyPair = this.ec.keyFromPrivate(this.keyPair.privateKey, 'hex');
+        const signature = keyPair.sign(plugins.crypto.createHash('sha256').update(data).digest());
+        return Buffer.from(signature.toDER());
+    }
+    generateDNSKEY() {
+        const flags = 256; // 256 indicates a Zone Signing Key (ZSK)
+        const protocol = 3; // Must be 3 according to RFC
+        const algorithm = this.getAlgorithmNumber();
+        let publicKeyData;
+        switch (this.zone.algorithm) {
+            case 'ECDSA':
+                if (!this.ec)
+                    throw new Error('EC instance is not initialized.');
+                const ecPublicKey = this.ec.keyFromPublic(this.keyPair.publicKey, 'hex').getPublic();
+                const x = ecPublicKey.getX().toArrayLike(Buffer, 'be', 32);
+                const y = ecPublicKey.getY().toArrayLike(Buffer, 'be', 32);
+                publicKeyData = Buffer.concat([x, y]);
+                break;
+            case 'ED25519':
+                publicKeyData = Buffer.from(this.keyPair.publicKey, 'hex');
+                break;
+            case 'RSA':
+                // RSA public key extraction would go here
+                throw new Error('RSA public key extraction is not yet implemented.');
+            default:
+                throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
+        }
+        // Construct the DNSKEY RDATA
+        const dnskeyRdata = Buffer.concat([
+            Buffer.from([flags >> 8, flags & 0xff]), // Flags (2 bytes)
+            Buffer.from([protocol]), // Protocol (1 byte)
+            Buffer.from([algorithm]), // Algorithm (1 byte)
+            publicKeyData, // Public Key
+        ]);
+        return dnskeyRdata;
+    }
+    computeKeyTag(dnskeyRdata) {
+        // Key Tag calculation as per RFC 4034, Appendix B
+        let acc = 0;
+        for (let i = 0; i < dnskeyRdata.length; i++) {
+            acc += i & 1 ? dnskeyRdata[i] : dnskeyRdata[i] << 8;
+        }
+        acc += (acc >> 16) & 0xffff;
+        return acc & 0xffff;
+    }
+    getDNSKEYRecord() {
+        const dnskeyRdata = this.generateDNSKEY();
+        const flags = 256;
+        const protocol = 3;
+        const algorithm = this.getAlgorithmNumber();
+        const publicKeyData = dnskeyRdata.slice(4); // Skip flags, protocol, algorithm bytes
+        const publicKeyBase64 = publicKeyData.toString('base64');
+        return `${this.zone.zone}. IN DNSKEY ${flags} ${protocol} ${algorithm} ${publicKeyBase64}`;
+    }
+    getDSRecord() {
+        const dnskeyRdata = this.generateDNSKEY();
+        const keyTag = this.computeKeyTag(dnskeyRdata);
+        const algorithm = this.getAlgorithmNumber();
+        const digestType = 2; // SHA-256
+        const digest = plugins.crypto
+            .createHash('sha256')
+            .update(dnskeyRdata)
+            .digest('hex')
+            .toUpperCase();
+        return `${this.zone.zone}. IN DS ${keyTag} ${algorithm} ${digestType} ${digest}`;
+    }
+    getKeyPair() {
+        return this.keyPair;
+    }
+    getDsAndKeyPair() {
+        const dsRecord = this.getDSRecord();
+        const dnskeyRecord = this.getDNSKEYRecord();
+        return { keyPair: this.keyPair, dsRecord, dnskeyRecord };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_server/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.dnsserver.js';

package/dist_ts_server/index.js

@@ -0,0 +1,2 @@
+export * from './classes.dnsserver.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyJ9

package/dist_ts_server/plugins.d.ts

@@ -0,0 +1,12 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import http from 'http';
+import https from 'https';
+import dgram from 'dgram';
+export { crypto, fs, http, https, dgram, };
+import * as smartpromise from '@push.rocks/smartpromise';
+export { smartpromise, };
+import elliptic from 'elliptic';
+import * as dnsPacket from 'dns-packet';
+import * as minimatch from 'minimatch';
+export { dnsPacket, elliptic, minimatch, };

package/dist_ts_server/plugins.js

@@ -0,0 +1,16 @@
+// node native
+import crypto from 'crypto';
+import fs from 'fs';
+import http from 'http';
+import https from 'https';
+import dgram from 'dgram';
+export { crypto, fs, http, https, dgram, };
+// @push.rocks scope
+import * as smartpromise from '@push.rocks/smartpromise';
+export { smartpromise, };
+// third party
+import elliptic from 'elliptic';
+import * as dnsPacket from 'dns-packet';
+import * as minimatch from 'minimatch';
+export { dnsPacket, elliptic, minimatch, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NlcnZlci9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFDNUIsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3BCLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUN4QixPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDMUIsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRTFCLE9BQU8sRUFDTCxNQUFNLEVBQ04sRUFBRSxFQUNGLElBQUksRUFDSixLQUFLLEVBQ0wsS0FBSyxHQUNOLENBQUE7QUFFRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxPQUFPLEVBQ0wsWUFBWSxHQUNiLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxRQUFRLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sWUFBWSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sV0FBVyxDQUFDO0FBRXZDLE9BQU8sRUFDTCxTQUFTLEVBQ1QsUUFBUSxFQUNSLFNBQVMsR0FDVixDQUFBIn0=

package/npmextra.json

@@ -2,17 +2,30 @@
   "gitzone": {
     "projectType": "npm",
     "module": {
-      "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
       "gitrepo": "smartdns",
-      "description": "smart dns methods written in TypeScript",
-      "npmPackagename": "@pushrocks/smartdns",
-      "license": "MIT"
+      "description": "A TypeScript library for smart DNS methods, supporting various DNS records and providers.",
+      "npmPackagename": "@push.rocks/smartdns",
+      "license": "MIT",
+      "keywords": [
+        "DNS",
+        "TypeScript",
+        "Node.js",
+        "Google DNS",
+        "Cloudflare",
+        "DNS records",
+        "DNS resolution",
+        "DNSSEC"
+      ]
     }
   },
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public",
     "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }