@push.rocks/smartdns 5.0.4 → 6.1.1

package/{dist_ts → dist_ts_client}/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts_client/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartdns',
+    version: '5.0.4',
+    description: 'smart dns methods written in TypeScript'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfY2xpZW50LzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSx5Q0FBeUM7Q0FDdkQsQ0FBQSJ9

package/{dist_ts/index.d.ts → dist_ts_client/classes.dnsclient.d.ts}

@@ -3,7 +3,7 @@ export type TDnsProvider = 'google' | 'cloudflare';
 export declare const makeNodeProcessUseDnsProvider: (providerArg: TDnsProvider) => void;
 export interface ISmartDnsConstructorOptions {
 }
-export interface IGoogleDNSHTTPSResponse {
+export interface IDnsJsonResponse {
     Status: number;
     TC: boolean;
     RD: boolean;
@@ -43,7 +43,7 @@ export declare class Smartdns {
      * @param recordTypeArg
      * @param expectedValue
      */
-    checkUntilAvailable(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType, expectedValue: string, cyclesArg?: number, intervalArg?: number): Promise<any>;
+    checkUntilAvailable(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType, expectedValue: string, cyclesArg?: number, intervalArg?: number): Promise<boolean>;
     /**
      * get A Dns Record
      */

package/dist_ts_client/classes.dnsclient.js

@@ -0,0 +1,186 @@
+import * as plugins from './dnsly.plugins.js';
+export const makeNodeProcessUseDnsProvider = (providerArg) => {
+    switch (providerArg) {
+        case 'cloudflare':
+            plugins.dns.setServers([
+                '1.1.1.1',
+                '1.0.0.1',
+                '[2606:4700:4700::1111]',
+                '[2606:4700:4700::1001]',
+            ]);
+            break;
+        case 'google':
+            plugins.dns.setServers([
+                '8.8.8.8',
+                '8.8.4.4',
+                '[2001:4860:4860::8888]',
+                '[2606:4700:4700::1001]',
+            ]);
+    }
+};
+/**
+ * class dnsly offers methods for working with dns from a dns provider like Google DNS
+ */
+export class Smartdns {
+    /**
+     * constructor for class dnsly
+     */
+    constructor(optionsArg) {
+        this.dnsTypeMap = {
+            A: 1,
+            AAAA: 28,
+            CNAME: 5,
+            MX: 15,
+            TXT: 16,
+        };
+    }
+    /**
+     * check a dns record until it has propagated to Google DNS
+     * should be considerably fast
+     * @param recordNameArg
+     * @param recordTypeArg
+     * @param expectedValue
+     */
+    async checkUntilAvailable(recordNameArg, recordTypeArg, expectedValue, cyclesArg = 50, intervalArg = 500) {
+        let runCycles = 0;
+        const doCheck = async () => {
+            if (runCycles < cyclesArg) {
+                runCycles++;
+                try {
+                    let myRecordArray;
+                    if (runCycles % 2 === 0 || !plugins.dns) {
+                        myRecordArray = await this.getRecords(recordNameArg, recordTypeArg, 0);
+                    }
+                    else {
+                        myRecordArray = await this.getRecordWithNodeDNS(recordNameArg, recordTypeArg);
+                    }
+                    const myRecord = myRecordArray[0].value;
+                    if (myRecord === expectedValue) {
+                        console.log(`smartdns: .checkUntilAvailable() verified that wanted >>>${recordTypeArg}<<< record exists for >>>${recordNameArg}<<< with value >>>${expectedValue}<<<`);
+                        return true;
+                    }
+                    else {
+                        await plugins.smartdelay.delayFor(intervalArg);
+                        return await doCheck();
+                    }
+                }
+                catch (err) {
+                    // console.log(err);
+                    await plugins.smartdelay.delayFor(intervalArg);
+                    return await doCheck();
+                }
+            }
+            else {
+                console.log(`smartdns: .checkUntilAvailable() failed permanently for ${recordNameArg} with value ${recordTypeArg} - ${expectedValue}...`);
+                return false;
+            }
+        };
+        return await doCheck();
+    }
+    /**
+     * get A Dns Record
+     */
+    async getRecordsA(recordNameArg) {
+        return await this.getRecords(recordNameArg, 'A');
+    }
+    /**
+     * get AAAA Record
+     */
+    async getRecordsAAAA(recordNameArg) {
+        return await this.getRecords(recordNameArg, 'AAAA');
+    }
+    /**
+     * gets a txt record
+     */
+    async getRecordsTxt(recordNameArg) {
+        return await this.getRecords(recordNameArg, 'TXT');
+    }
+    async getRecords(recordNameArg, recordTypeArg, retriesCounterArg = 20) {
+        const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
+        const returnArray = [];
+        const getResponseBody = async (counterArg = 0) => {
+            const response = await plugins.smartrequest.request(requestUrl, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/dns-json',
+                },
+            });
+            const responseBody = response.body;
+            if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
+                await plugins.smartdelay.delayFor(500);
+                return getResponseBody(counterArg++);
+            }
+            else {
+                return responseBody;
+            }
+        };
+        const responseBody = await getResponseBody();
+        if (!responseBody.Answer || !typeof responseBody.Answer[Symbol.iterator]) {
+            return returnArray;
+        }
+        for (const dnsEntry of responseBody.Answer) {
+            if (dnsEntry.data.startsWith('"') && dnsEntry.data.endsWith('"')) {
+                dnsEntry.data = dnsEntry.data.replace(/^"(.*)"$/, '$1');
+            }
+            if (dnsEntry.name.endsWith('.')) {
+                dnsEntry.name = dnsEntry.name.substring(0, dnsEntry.name.length - 1);
+            }
+            returnArray.push({
+                name: dnsEntry.name,
+                type: this.convertDnsTypeNumberToTypeName(dnsEntry.type),
+                dnsSecEnabled: responseBody.AD,
+                value: dnsEntry.data,
+            });
+        }
+        // console.log(responseBody);
+        return returnArray;
+    }
+    /**
+     * gets a record using nodejs dns resolver
+     */
+    async getRecordWithNodeDNS(recordNameArg, recordTypeArg) {
+        const done = plugins.smartpromise.defer();
+        plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
+            if (err) {
+                done.reject(err);
+                return;
+            }
+            const returnArray = [];
+            for (const recordKey in recordsArg) {
+                returnArray.push({
+                    name: recordNameArg,
+                    value: recordsArg[recordKey][0],
+                    type: recordTypeArg,
+                    dnsSecEnabled: false,
+                });
+            }
+            done.resolve(returnArray);
+        });
+        return done.promise;
+    }
+    async getNameServers(domainNameArg) {
+        const done = plugins.smartpromise.defer();
+        plugins.dns.resolveNs(domainNameArg, (err, result) => {
+            if (!err) {
+                done.resolve(result);
+            }
+            else {
+                console.log(err);
+                done.reject(err);
+            }
+        });
+        return await done.promise;
+    }
+    convertDnsTypeNameToTypeNumber(dnsTypeNameArg) {
+        return this.dnsTypeMap[dnsTypeNameArg];
+    }
+    convertDnsTypeNumberToTypeName(dnsTypeNumberArg) {
+        for (const key in this.dnsTypeMap) {
+            if (this.dnsTypeMap[key] === dnsTypeNumberArg) {
+                return key;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_client/dnsly.plugins.d.ts

@@ -0,0 +1,10 @@
+import * as smartenv from '@push.rocks/smartenv';
+import type dnsType from 'dns';
+declare const dns: typeof dnsType;
+export { dns };
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };

package/dist_ts_client/dnsly.plugins.js

@@ -0,0 +1,12 @@
+import * as smartenv from '@push.rocks/smartenv';
+const smartenvInstance = new smartenv.Smartenv();
+const dns = await smartenvInstance.getSafeNodeModule('dns');
+export { dns };
+// pushrocks scope
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9kbnNseS5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUdqRCxNQUFNLEdBQUcsR0FBbUIsTUFBTSxnQkFBZ0IsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUU1RSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFZixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRTVELE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=

package/dist_ts_client/index.d.ts

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

package/dist_ts_client/index.js

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

package/dist_ts_server/classes.dnsserver.d.ts

@@ -0,0 +1,20 @@
+import * as plugins from './plugins.js';
+interface IDnsServerOptions {
+    httpsKey: string;
+    httpsCert: string;
+    httpsPort: number;
+    udpPort: number;
+}
+export declare class DnsServer {
+    private options;
+    private udpServer;
+    private httpsServer;
+    private handlers;
+    constructor(options: IDnsServerOptions);
+    registerHandler(domainPattern: string, recordTypes: string[], handler: (question: plugins.dnsPacket.Question) => plugins.dnsPacket.Answer | null): void;
+    private processDnsRequest;
+    private handleHttpsRequest;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};

package/dist_ts_server/classes.dnsserver.js

@@ -0,0 +1,109 @@
+import * as plugins from './plugins.js';
+export class DnsServer {
+    constructor(options) {
+        this.options = options;
+        this.handlers = [];
+    }
+    registerHandler(domainPattern, recordTypes, handler) {
+        this.handlers.push({ domainPattern, recordTypes, handler });
+    }
+    processDnsRequest(request) {
+        const response = {
+            type: 'response',
+            id: request.id,
+            flags: plugins.dnsPacket.RECURSION_DESIRED | plugins.dnsPacket.RECURSION_AVAILABLE,
+            questions: request.questions,
+            answers: [],
+        };
+        for (const question of request.questions) {
+            console.log(`Query for ${question.name} of type ${question.type}`);
+            let answered = false;
+            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) {
+                        response.answers.push(answer);
+                        answered = true;
+                        break;
+                    }
+                }
+            }
+            if (!answered) {
+                console.log(`No handler found for ${question.name} of type ${question.type}`);
+            }
+        }
+        return response;
+    }
+    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 = plugins.dnsPacket.decode(msg);
+                const response = this.processDnsRequest(request);
+                const responseData = plugins.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 = plugins.dnsPacket.decode(msg);
+            const response = this.processDnsRequest(request);
+            const responseData = plugins.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]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5kbnNzZXJ2ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19zZXJ2ZXIvY2xhc3Nlcy5kbnNzZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFleEMsTUFBTSxPQUFPLFNBQVM7SUFLcEIsWUFBb0IsT0FBMEI7UUFBMUIsWUFBTyxHQUFQLE9BQU8sQ0FBbUI7UUFGdEMsYUFBUSxHQUFrQixFQUFFLENBQUM7SUFFWSxDQUFDO0lBRTNDLGVBQWUsQ0FDcEIsYUFBcUIsRUFDckIsV0FBcUIsRUFDckIsT0FBa0Y7UUFFbEYsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVPLGlCQUFpQixDQUFDLE9BQWlDO1FBQ3pELE1BQU0sUUFBUSxHQUE2QjtZQUN6QyxJQUFJLEVBQUUsVUFBVTtZQUNoQixFQUFFLEVBQUUsT0FBTyxDQUFDLEVBQUU7WUFDZCxLQUFLLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxpQkFBaUIsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLG1CQUFtQjtZQUNsRixTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVM7WUFDNUIsT0FBTyxFQUFFLEVBQUU7U0FDWixDQUFDO1FBRUYsS0FBSyxNQUFNLFFBQVEsSUFBSSxPQUFPLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDekMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLFFBQVEsQ0FBQyxJQUFJLFlBQVksUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7WUFFbkUsSUFBSSxRQUFRLEdBQUcsS0FBSyxDQUFDO1lBRXJCLEtBQUssTUFBTSxZQUFZLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN6QyxJQUNFLE9BQU8sQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDLGFBQWEsQ0FBQztvQkFDdEUsWUFBWSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxFQUNoRCxDQUFDO29CQUNELE1BQU0sTUFBTSxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7b0JBQzlDLElBQUksTUFBTSxFQUFFLENBQUM7d0JBQ1gsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7d0JBQzlCLFFBQVEsR0FBRyxJQUFJLENBQUM7d0JBQ2hCLE1BQU07b0JBQ1IsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztZQUVELElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDZCxPQUFPLENBQUMsR0FBRyxDQUFDLHdCQUF3QixRQUFRLENBQUMsSUFBSSxZQUFZLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2hGLENBQUM7UUFDSCxDQUFDO1FBRUQsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztJQUVPLGtCQUFrQixDQUFDLEdBQWlDLEVBQUUsR0FBZ0M7UUFDNUYsSUFBSSxHQUFHLENBQUMsTUFBTSxLQUFLLE1BQU0sSUFBSSxHQUFHLENBQUMsR0FBRyxLQUFLLFlBQVksRUFBRSxDQUFDO1lBQ3RELElBQUksSUFBSSxHQUFhLEVBQUUsQ0FBQztZQUV4QixHQUFHLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsRUFBRTtnQkFDckIsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUNuQixDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRTtnQkFDaEIsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDaEMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQzlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztnQkFDakQsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ3hELEdBQUcsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLEVBQUUsY0FBYyxFQUFFLHlCQUF5QixFQUFFLENBQUMsQ0FBQztnQkFDbEUsR0FBRyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQztZQUN4QixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7YUFBTSxDQUFDO1lBQ04sR0FBRyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNuQixHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDWixDQUFDO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLElBQUksQ0FBQyxXQUFXLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQzNDO1lBQ0UsR0FBRyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUTtZQUMxQixJQUFJLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTO1NBQzdCLEVBQ0QsSUFBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FDbkMsQ0FBQztRQUVGLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsU0FBUyxFQUFFLENBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFO1lBQzFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzlDLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNqRCxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN4RCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsS0FBSyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDL0QsQ0FBQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUNqQyxPQUFPLENBQUMsS0FBSyxDQUFDLHNCQUFzQixHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUNqRCxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO1FBRUgsTUFBTSxvQkFBb0IsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBUSxDQUFDO1FBQ2hFLE1BQU0sc0JBQXNCLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQVEsQ0FBQztRQUNsRSxJQUFJLENBQUM7WUFDSCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxTQUFTLEVBQUUsR0FBRyxFQUFFO2dCQUN4RCxPQUFPLENBQUMsR0FBRyxDQUFDLGtDQUFrQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7Z0JBQ3RFLG9CQUFvQixDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2pDLENBQUMsQ0FBQyxDQUFDO1lBRUgsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLEVBQUUsR0FBRyxFQUFFO2dCQUNuRCxPQUFPLENBQUMsR0FBRyxDQUFDLG9DQUFvQyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7Z0JBQzFFLHNCQUFzQixDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ25DLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixPQUFPLENBQUMsS0FBSyxDQUFDLDRCQUE0QixFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQ2pELE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDbEIsQ0FBQztRQUNELE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLG9CQUFvQixDQUFDLE9BQU8sRUFBRSxzQkFBc0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ3BGLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFRLENBQUM7UUFDbkQsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQVEsQ0FBQztRQUNyRCxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUU7WUFDeEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO1lBQ3RDLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7WUFDdEIsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFO1lBQzFCLE9BQU8sQ0FBQyxHQUFHLENBQUMsMEJBQTBCLENBQUMsQ0FBQztZQUN4QyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1lBQ3hCLFNBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUN0QixDQUFDLENBQUMsQ0FBQztRQUVILE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDMUQsQ0FBQztDQUNGIn0=

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 * as 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 * as elliptic from 'elliptic';
+import * as dnsPacket from 'dns-packet';
+import * as minimatch from 'minimatch';
+export { dnsPacket, elliptic, minimatch, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3NlcnZlci9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFDNUIsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3BCLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUN4QixPQUFPLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDMUIsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRTFCLE9BQU8sRUFDTCxNQUFNLEVBQ04sRUFBRSxFQUNGLElBQUksRUFDSixLQUFLLEVBQ0wsS0FBSyxHQUNOLENBQUE7QUFFRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxPQUFPLEVBQ0wsWUFBWSxHQUNiLENBQUE7QUFFRCxjQUFjO0FBQ2QsT0FBTyxLQUFLLFFBQVEsTUFBTSxVQUFVLENBQUM7QUFDckMsT0FBTyxLQUFLLFNBQVMsTUFBTSxZQUFZLENBQUM7QUFDeEMsT0FBTyxLQUFLLFNBQVMsTUFBTSxXQUFXLENBQUM7QUFFdkMsT0FBTyxFQUNMLFNBQVMsRUFDVCxRQUFRLEVBQ1IsU0FBUyxHQUNWLENBQUEifQ==