@push.rocks/smartdns 5.0.4 → 6.2.0

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.dnssec.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;
+    getAlgorithmNumber(): number;
+    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.dnssec.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/classes.dnsserver.d.ts

@@ -0,0 +1,40 @@
+import * as dnsPacket from 'dns-packet';
+interface IDnsServerOptions {
+    httpsKey: string;
+    httpsCert: string;
+    httpsPort: number;
+    udpPort: number;
+    dnssecZone: string;
+}
+interface DnsAnswer {
+    name: string;
+    type: string;
+    class: string | number;
+    ttl: number;
+    data: any;
+}
+export declare class DnsServer {
+    private options;
+    private udpServer;
+    private httpsServer;
+    private handlers;
+    private dnsSec;
+    private dnskeyRecord;
+    private keyTag;
+    constructor(options: IDnsServerOptions);
+    registerHandler(domainPattern: string, recordTypes: string[], handler: (question: dnsPacket.Question) => DnsAnswer | null): void;
+    private processDnsRequest;
+    private isDnssecRequested;
+    private generateRRSIG;
+    private serializeRRset;
+    private serializeRData;
+    private parseDNSKEYRecord;
+    private computeKeyTag;
+    private handleHttpsRequest;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private qtypeToNumber;
+    private classToNumber;
+    private nameToBuffer;
+}
+export {};